001package org.hl7.fhir.dstu3.model;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
035import java.util.ArrayList;
036import java.util.Date;
037import java.util.List;
038
039import org.hl7.fhir.exceptions.FHIRException;
040import org.hl7.fhir.exceptions.FHIRFormatError;
041import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
042import org.hl7.fhir.utilities.Utilities;
043
044import ca.uhn.fhir.model.api.annotation.Block;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.Description;
047import ca.uhn.fhir.model.api.annotation.ResourceDef;
048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
049/**
050 * A set of healthcare-related information that is assembled together into a single logical document that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. While a Composition defines the structure, it does not actually contain the content: rather the full content of a document is contained in a Bundle, of which the Composition is the first resource contained.
051 */
052@ResourceDef(name="Composition", profile="http://hl7.org/fhir/Profile/Composition")
053public class Composition extends DomainResource {
054
055    public enum CompositionStatus {
056        /**
057         * This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified.
058         */
059        PRELIMINARY, 
060        /**
061         * This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.
062         */
063        FINAL, 
064        /**
065         * The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as "final" and the composition is complete and verified by an authorized person.
066         */
067        AMENDED, 
068        /**
069         * The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.
070         */
071        ENTEREDINERROR, 
072        /**
073         * added to help the parsers with the generic types
074         */
075        NULL;
076        public static CompositionStatus fromCode(String codeString) throws FHIRException {
077            if (codeString == null || "".equals(codeString))
078                return null;
079        if ("preliminary".equals(codeString))
080          return PRELIMINARY;
081        if ("final".equals(codeString))
082          return FINAL;
083        if ("amended".equals(codeString))
084          return AMENDED;
085        if ("entered-in-error".equals(codeString))
086          return ENTEREDINERROR;
087        if (Configuration.isAcceptInvalidEnums())
088          return null;
089        else
090          throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
091        }
092        public String toCode() {
093          switch (this) {
094            case PRELIMINARY: return "preliminary";
095            case FINAL: return "final";
096            case AMENDED: return "amended";
097            case ENTEREDINERROR: return "entered-in-error";
098            case NULL: return null;
099            default: return "?";
100          }
101        }
102        public String getSystem() {
103          switch (this) {
104            case PRELIMINARY: return "http://hl7.org/fhir/composition-status";
105            case FINAL: return "http://hl7.org/fhir/composition-status";
106            case AMENDED: return "http://hl7.org/fhir/composition-status";
107            case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status";
108            case NULL: return null;
109            default: return "?";
110          }
111        }
112        public String getDefinition() {
113          switch (this) {
114            case PRELIMINARY: return "This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified.";
115            case FINAL: return "This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.";
116            case AMENDED: return "The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as \"final\" and the composition is complete and verified by an authorized person.";
117            case ENTEREDINERROR: return "The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.";
118            case NULL: return null;
119            default: return "?";
120          }
121        }
122        public String getDisplay() {
123          switch (this) {
124            case PRELIMINARY: return "Preliminary";
125            case FINAL: return "Final";
126            case AMENDED: return "Amended";
127            case ENTEREDINERROR: return "Entered in Error";
128            case NULL: return null;
129            default: return "?";
130          }
131        }
132    }
133
134  public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> {
135    public CompositionStatus fromCode(String codeString) throws IllegalArgumentException {
136      if (codeString == null || "".equals(codeString))
137            if (codeString == null || "".equals(codeString))
138                return null;
139        if ("preliminary".equals(codeString))
140          return CompositionStatus.PRELIMINARY;
141        if ("final".equals(codeString))
142          return CompositionStatus.FINAL;
143        if ("amended".equals(codeString))
144          return CompositionStatus.AMENDED;
145        if ("entered-in-error".equals(codeString))
146          return CompositionStatus.ENTEREDINERROR;
147        throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'");
148        }
149        public Enumeration<CompositionStatus> fromType(Base code) throws FHIRException {
150          if (code == null)
151            return null;
152          if (code.isEmpty())
153            return new Enumeration<CompositionStatus>(this);
154          String codeString = ((PrimitiveType) code).asStringValue();
155          if (codeString == null || "".equals(codeString))
156            return null;
157        if ("preliminary".equals(codeString))
158          return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY);
159        if ("final".equals(codeString))
160          return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL);
161        if ("amended".equals(codeString))
162          return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED);
163        if ("entered-in-error".equals(codeString))
164          return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR);
165        throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
166        }
167    public String toCode(CompositionStatus code) {
168      if (code == CompositionStatus.PRELIMINARY)
169        return "preliminary";
170      if (code == CompositionStatus.FINAL)
171        return "final";
172      if (code == CompositionStatus.AMENDED)
173        return "amended";
174      if (code == CompositionStatus.ENTEREDINERROR)
175        return "entered-in-error";
176      return "?";
177      }
178    public String toSystem(CompositionStatus code) {
179      return code.getSystem();
180      }
181    }
182
183    public enum DocumentConfidentiality {
184        /**
185         * null
186         */
187        U, 
188        /**
189         * null
190         */
191        L, 
192        /**
193         * null
194         */
195        M, 
196        /**
197         * null
198         */
199        N, 
200        /**
201         * null
202         */
203        R, 
204        /**
205         * null
206         */
207        V, 
208        /**
209         * added to help the parsers with the generic types
210         */
211        NULL;
212        public static DocumentConfidentiality fromCode(String codeString) throws FHIRException {
213            if (codeString == null || "".equals(codeString))
214                return null;
215        if ("U".equals(codeString))
216          return U;
217        if ("L".equals(codeString))
218          return L;
219        if ("M".equals(codeString))
220          return M;
221        if ("N".equals(codeString))
222          return N;
223        if ("R".equals(codeString))
224          return R;
225        if ("V".equals(codeString))
226          return V;
227        if (Configuration.isAcceptInvalidEnums())
228          return null;
229        else
230          throw new FHIRException("Unknown DocumentConfidentiality code '"+codeString+"'");
231        }
232        public String toCode() {
233          switch (this) {
234            case U: return "U";
235            case L: return "L";
236            case M: return "M";
237            case N: return "N";
238            case R: return "R";
239            case V: return "V";
240            case NULL: return null;
241            default: return "?";
242          }
243        }
244        public String getSystem() {
245          switch (this) {
246            case U: return "http://hl7.org/fhir/v3/Confidentiality";
247            case L: return "http://hl7.org/fhir/v3/Confidentiality";
248            case M: return "http://hl7.org/fhir/v3/Confidentiality";
249            case N: return "http://hl7.org/fhir/v3/Confidentiality";
250            case R: return "http://hl7.org/fhir/v3/Confidentiality";
251            case V: return "http://hl7.org/fhir/v3/Confidentiality";
252            case NULL: return null;
253            default: return "?";
254          }
255        }
256        public String getDefinition() {
257          switch (this) {
258            case U: return "";
259            case L: return "";
260            case M: return "";
261            case N: return "";
262            case R: return "";
263            case V: return "";
264            case NULL: return null;
265            default: return "?";
266          }
267        }
268        public String getDisplay() {
269          switch (this) {
270            case U: return "U";
271            case L: return "L";
272            case M: return "M";
273            case N: return "N";
274            case R: return "R";
275            case V: return "V";
276            case NULL: return null;
277            default: return "?";
278          }
279        }
280    }
281
282  public static class DocumentConfidentialityEnumFactory implements EnumFactory<DocumentConfidentiality> {
283    public DocumentConfidentiality fromCode(String codeString) throws IllegalArgumentException {
284      if (codeString == null || "".equals(codeString))
285            if (codeString == null || "".equals(codeString))
286                return null;
287        if ("U".equals(codeString))
288          return DocumentConfidentiality.U;
289        if ("L".equals(codeString))
290          return DocumentConfidentiality.L;
291        if ("M".equals(codeString))
292          return DocumentConfidentiality.M;
293        if ("N".equals(codeString))
294          return DocumentConfidentiality.N;
295        if ("R".equals(codeString))
296          return DocumentConfidentiality.R;
297        if ("V".equals(codeString))
298          return DocumentConfidentiality.V;
299        throw new IllegalArgumentException("Unknown DocumentConfidentiality code '"+codeString+"'");
300        }
301        public Enumeration<DocumentConfidentiality> fromType(Base code) throws FHIRException {
302          if (code == null)
303            return null;
304          if (code.isEmpty())
305            return new Enumeration<DocumentConfidentiality>(this);
306          String codeString = ((PrimitiveType) code).asStringValue();
307          if (codeString == null || "".equals(codeString))
308            return null;
309        if ("U".equals(codeString))
310          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.U);
311        if ("L".equals(codeString))
312          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.L);
313        if ("M".equals(codeString))
314          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.M);
315        if ("N".equals(codeString))
316          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.N);
317        if ("R".equals(codeString))
318          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.R);
319        if ("V".equals(codeString))
320          return new Enumeration<DocumentConfidentiality>(this, DocumentConfidentiality.V);
321        throw new FHIRException("Unknown DocumentConfidentiality code '"+codeString+"'");
322        }
323    public String toCode(DocumentConfidentiality code) {
324      if (code == DocumentConfidentiality.U)
325        return "U";
326      if (code == DocumentConfidentiality.L)
327        return "L";
328      if (code == DocumentConfidentiality.M)
329        return "M";
330      if (code == DocumentConfidentiality.N)
331        return "N";
332      if (code == DocumentConfidentiality.R)
333        return "R";
334      if (code == DocumentConfidentiality.V)
335        return "V";
336      return "?";
337      }
338    public String toSystem(DocumentConfidentiality code) {
339      return code.getSystem();
340      }
341    }
342
343    public enum CompositionAttestationMode {
344        /**
345         * The person authenticated the content in their personal capacity.
346         */
347        PERSONAL, 
348        /**
349         * The person authenticated the content in their professional capacity.
350         */
351        PROFESSIONAL, 
352        /**
353         * The person authenticated the content and accepted legal responsibility for its content.
354         */
355        LEGAL, 
356        /**
357         * The organization authenticated the content as consistent with their policies and procedures.
358         */
359        OFFICIAL, 
360        /**
361         * added to help the parsers with the generic types
362         */
363        NULL;
364        public static CompositionAttestationMode fromCode(String codeString) throws FHIRException {
365            if (codeString == null || "".equals(codeString))
366                return null;
367        if ("personal".equals(codeString))
368          return PERSONAL;
369        if ("professional".equals(codeString))
370          return PROFESSIONAL;
371        if ("legal".equals(codeString))
372          return LEGAL;
373        if ("official".equals(codeString))
374          return OFFICIAL;
375        if (Configuration.isAcceptInvalidEnums())
376          return null;
377        else
378          throw new FHIRException("Unknown CompositionAttestationMode code '"+codeString+"'");
379        }
380        public String toCode() {
381          switch (this) {
382            case PERSONAL: return "personal";
383            case PROFESSIONAL: return "professional";
384            case LEGAL: return "legal";
385            case OFFICIAL: return "official";
386            case NULL: return null;
387            default: return "?";
388          }
389        }
390        public String getSystem() {
391          switch (this) {
392            case PERSONAL: return "http://hl7.org/fhir/composition-attestation-mode";
393            case PROFESSIONAL: return "http://hl7.org/fhir/composition-attestation-mode";
394            case LEGAL: return "http://hl7.org/fhir/composition-attestation-mode";
395            case OFFICIAL: return "http://hl7.org/fhir/composition-attestation-mode";
396            case NULL: return null;
397            default: return "?";
398          }
399        }
400        public String getDefinition() {
401          switch (this) {
402            case PERSONAL: return "The person authenticated the content in their personal capacity.";
403            case PROFESSIONAL: return "The person authenticated the content in their professional capacity.";
404            case LEGAL: return "The person authenticated the content and accepted legal responsibility for its content.";
405            case OFFICIAL: return "The organization authenticated the content as consistent with their policies and procedures.";
406            case NULL: return null;
407            default: return "?";
408          }
409        }
410        public String getDisplay() {
411          switch (this) {
412            case PERSONAL: return "Personal";
413            case PROFESSIONAL: return "Professional";
414            case LEGAL: return "Legal";
415            case OFFICIAL: return "Official";
416            case NULL: return null;
417            default: return "?";
418          }
419        }
420    }
421
422  public static class CompositionAttestationModeEnumFactory implements EnumFactory<CompositionAttestationMode> {
423    public CompositionAttestationMode fromCode(String codeString) throws IllegalArgumentException {
424      if (codeString == null || "".equals(codeString))
425            if (codeString == null || "".equals(codeString))
426                return null;
427        if ("personal".equals(codeString))
428          return CompositionAttestationMode.PERSONAL;
429        if ("professional".equals(codeString))
430          return CompositionAttestationMode.PROFESSIONAL;
431        if ("legal".equals(codeString))
432          return CompositionAttestationMode.LEGAL;
433        if ("official".equals(codeString))
434          return CompositionAttestationMode.OFFICIAL;
435        throw new IllegalArgumentException("Unknown CompositionAttestationMode code '"+codeString+"'");
436        }
437        public Enumeration<CompositionAttestationMode> fromType(Base code) throws FHIRException {
438          if (code == null)
439            return null;
440          if (code.isEmpty())
441            return new Enumeration<CompositionAttestationMode>(this);
442          String codeString = ((PrimitiveType) code).asStringValue();
443          if (codeString == null || "".equals(codeString))
444            return null;
445        if ("personal".equals(codeString))
446          return new Enumeration<CompositionAttestationMode>(this, CompositionAttestationMode.PERSONAL);
447        if ("professional".equals(codeString))
448          return new Enumeration<CompositionAttestationMode>(this, CompositionAttestationMode.PROFESSIONAL);
449        if ("legal".equals(codeString))
450          return new Enumeration<CompositionAttestationMode>(this, CompositionAttestationMode.LEGAL);
451        if ("official".equals(codeString))
452          return new Enumeration<CompositionAttestationMode>(this, CompositionAttestationMode.OFFICIAL);
453        throw new FHIRException("Unknown CompositionAttestationMode code '"+codeString+"'");
454        }
455    public String toCode(CompositionAttestationMode code) {
456      if (code == CompositionAttestationMode.PERSONAL)
457        return "personal";
458      if (code == CompositionAttestationMode.PROFESSIONAL)
459        return "professional";
460      if (code == CompositionAttestationMode.LEGAL)
461        return "legal";
462      if (code == CompositionAttestationMode.OFFICIAL)
463        return "official";
464      return "?";
465      }
466    public String toSystem(CompositionAttestationMode code) {
467      return code.getSystem();
468      }
469    }
470
471    public enum DocumentRelationshipType {
472        /**
473         * This document logically replaces or supersedes the target document.
474         */
475        REPLACES, 
476        /**
477         * This document was generated by transforming the target document (e.g. format or language conversion).
478         */
479        TRANSFORMS, 
480        /**
481         * This document is a signature of the target document.
482         */
483        SIGNS, 
484        /**
485         * This document adds additional information to the target document.
486         */
487        APPENDS, 
488        /**
489         * added to help the parsers with the generic types
490         */
491        NULL;
492        public static DocumentRelationshipType fromCode(String codeString) throws FHIRException {
493            if (codeString == null || "".equals(codeString))
494                return null;
495        if ("replaces".equals(codeString))
496          return REPLACES;
497        if ("transforms".equals(codeString))
498          return TRANSFORMS;
499        if ("signs".equals(codeString))
500          return SIGNS;
501        if ("appends".equals(codeString))
502          return APPENDS;
503        if (Configuration.isAcceptInvalidEnums())
504          return null;
505        else
506          throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'");
507        }
508        public String toCode() {
509          switch (this) {
510            case REPLACES: return "replaces";
511            case TRANSFORMS: return "transforms";
512            case SIGNS: return "signs";
513            case APPENDS: return "appends";
514            case NULL: return null;
515            default: return "?";
516          }
517        }
518        public String getSystem() {
519          switch (this) {
520            case REPLACES: return "http://hl7.org/fhir/document-relationship-type";
521            case TRANSFORMS: return "http://hl7.org/fhir/document-relationship-type";
522            case SIGNS: return "http://hl7.org/fhir/document-relationship-type";
523            case APPENDS: return "http://hl7.org/fhir/document-relationship-type";
524            case NULL: return null;
525            default: return "?";
526          }
527        }
528        public String getDefinition() {
529          switch (this) {
530            case REPLACES: return "This document logically replaces or supersedes the target document.";
531            case TRANSFORMS: return "This document was generated by transforming the target document (e.g. format or language conversion).";
532            case SIGNS: return "This document is a signature of the target document.";
533            case APPENDS: return "This document adds additional information to the target document.";
534            case NULL: return null;
535            default: return "?";
536          }
537        }
538        public String getDisplay() {
539          switch (this) {
540            case REPLACES: return "Replaces";
541            case TRANSFORMS: return "Transforms";
542            case SIGNS: return "Signs";
543            case APPENDS: return "Appends";
544            case NULL: return null;
545            default: return "?";
546          }
547        }
548    }
549
550  public static class DocumentRelationshipTypeEnumFactory implements EnumFactory<DocumentRelationshipType> {
551    public DocumentRelationshipType fromCode(String codeString) throws IllegalArgumentException {
552      if (codeString == null || "".equals(codeString))
553            if (codeString == null || "".equals(codeString))
554                return null;
555        if ("replaces".equals(codeString))
556          return DocumentRelationshipType.REPLACES;
557        if ("transforms".equals(codeString))
558          return DocumentRelationshipType.TRANSFORMS;
559        if ("signs".equals(codeString))
560          return DocumentRelationshipType.SIGNS;
561        if ("appends".equals(codeString))
562          return DocumentRelationshipType.APPENDS;
563        throw new IllegalArgumentException("Unknown DocumentRelationshipType code '"+codeString+"'");
564        }
565        public Enumeration<DocumentRelationshipType> fromType(Base code) throws FHIRException {
566          if (code == null)
567            return null;
568          if (code.isEmpty())
569            return new Enumeration<DocumentRelationshipType>(this);
570          String codeString = ((PrimitiveType) code).asStringValue();
571          if (codeString == null || "".equals(codeString))
572            return null;
573        if ("replaces".equals(codeString))
574          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.REPLACES);
575        if ("transforms".equals(codeString))
576          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.TRANSFORMS);
577        if ("signs".equals(codeString))
578          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.SIGNS);
579        if ("appends".equals(codeString))
580          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.APPENDS);
581        throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'");
582        }
583    public String toCode(DocumentRelationshipType code) {
584      if (code == DocumentRelationshipType.REPLACES)
585        return "replaces";
586      if (code == DocumentRelationshipType.TRANSFORMS)
587        return "transforms";
588      if (code == DocumentRelationshipType.SIGNS)
589        return "signs";
590      if (code == DocumentRelationshipType.APPENDS)
591        return "appends";
592      return "?";
593      }
594    public String toSystem(DocumentRelationshipType code) {
595      return code.getSystem();
596      }
597    }
598
599    public enum SectionMode {
600        /**
601         * This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes
602         */
603        WORKING, 
604        /**
605         * This list was prepared as a snapshot. It should not be assumed to be current
606         */
607        SNAPSHOT, 
608        /**
609         * A list that indicates where changes have been made or recommended
610         */
611        CHANGES, 
612        /**
613         * added to help the parsers with the generic types
614         */
615        NULL;
616        public static SectionMode fromCode(String codeString) throws FHIRException {
617            if (codeString == null || "".equals(codeString))
618                return null;
619        if ("working".equals(codeString))
620          return WORKING;
621        if ("snapshot".equals(codeString))
622          return SNAPSHOT;
623        if ("changes".equals(codeString))
624          return CHANGES;
625        if (Configuration.isAcceptInvalidEnums())
626          return null;
627        else
628          throw new FHIRException("Unknown SectionMode code '"+codeString+"'");
629        }
630        public String toCode() {
631          switch (this) {
632            case WORKING: return "working";
633            case SNAPSHOT: return "snapshot";
634            case CHANGES: return "changes";
635            case NULL: return null;
636            default: return "?";
637          }
638        }
639        public String getSystem() {
640          switch (this) {
641            case WORKING: return "http://hl7.org/fhir/list-mode";
642            case SNAPSHOT: return "http://hl7.org/fhir/list-mode";
643            case CHANGES: return "http://hl7.org/fhir/list-mode";
644            case NULL: return null;
645            default: return "?";
646          }
647        }
648        public String getDefinition() {
649          switch (this) {
650            case WORKING: return "This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes";
651            case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current";
652            case CHANGES: return "A list that indicates where changes have been made or recommended";
653            case NULL: return null;
654            default: return "?";
655          }
656        }
657        public String getDisplay() {
658          switch (this) {
659            case WORKING: return "Working List";
660            case SNAPSHOT: return "Snapshot List";
661            case CHANGES: return "Change List";
662            case NULL: return null;
663            default: return "?";
664          }
665        }
666    }
667
668  public static class SectionModeEnumFactory implements EnumFactory<SectionMode> {
669    public SectionMode fromCode(String codeString) throws IllegalArgumentException {
670      if (codeString == null || "".equals(codeString))
671            if (codeString == null || "".equals(codeString))
672                return null;
673        if ("working".equals(codeString))
674          return SectionMode.WORKING;
675        if ("snapshot".equals(codeString))
676          return SectionMode.SNAPSHOT;
677        if ("changes".equals(codeString))
678          return SectionMode.CHANGES;
679        throw new IllegalArgumentException("Unknown SectionMode code '"+codeString+"'");
680        }
681        public Enumeration<SectionMode> fromType(Base code) throws FHIRException {
682          if (code == null)
683            return null;
684          if (code.isEmpty())
685            return new Enumeration<SectionMode>(this);
686          String codeString = ((PrimitiveType) code).asStringValue();
687          if (codeString == null || "".equals(codeString))
688            return null;
689        if ("working".equals(codeString))
690          return new Enumeration<SectionMode>(this, SectionMode.WORKING);
691        if ("snapshot".equals(codeString))
692          return new Enumeration<SectionMode>(this, SectionMode.SNAPSHOT);
693        if ("changes".equals(codeString))
694          return new Enumeration<SectionMode>(this, SectionMode.CHANGES);
695        throw new FHIRException("Unknown SectionMode code '"+codeString+"'");
696        }
697    public String toCode(SectionMode code) {
698      if (code == SectionMode.WORKING)
699        return "working";
700      if (code == SectionMode.SNAPSHOT)
701        return "snapshot";
702      if (code == SectionMode.CHANGES)
703        return "changes";
704      return "?";
705      }
706    public String toSystem(SectionMode code) {
707      return code.getSystem();
708      }
709    }
710
711    @Block()
712    public static class CompositionAttesterComponent extends BackboneElement implements IBaseBackboneElement {
713        /**
714         * The type of attestation the authenticator offers.
715         */
716        @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
717        @Description(shortDefinition="personal | professional | legal | official", formalDefinition="The type of attestation the authenticator offers." )
718        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/composition-attestation-mode")
719        protected List<Enumeration<CompositionAttestationMode>> mode;
720
721        /**
722         * When the composition was attested by the party.
723         */
724        @Child(name = "time", type = {DateTimeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
725        @Description(shortDefinition="When the composition was attested", formalDefinition="When the composition was attested by the party." )
726        protected DateTimeType time;
727
728        /**
729         * Who attested the composition in the specified way.
730         */
731        @Child(name = "party", type = {Patient.class, Practitioner.class, Organization.class}, order=3, min=0, max=1, modifier=false, summary=true)
732        @Description(shortDefinition="Who attested the composition", formalDefinition="Who attested the composition in the specified way." )
733        protected Reference party;
734
735        /**
736         * The actual object that is the target of the reference (Who attested the composition in the specified way.)
737         */
738        protected Resource partyTarget;
739
740        private static final long serialVersionUID = -436604745L;
741
742    /**
743     * Constructor
744     */
745      public CompositionAttesterComponent() {
746        super();
747      }
748
749        /**
750         * @return {@link #mode} (The type of attestation the authenticator offers.)
751         */
752        public List<Enumeration<CompositionAttestationMode>> getMode() { 
753          if (this.mode == null)
754            this.mode = new ArrayList<Enumeration<CompositionAttestationMode>>();
755          return this.mode;
756        }
757
758        /**
759         * @return Returns a reference to <code>this</code> for easy method chaining
760         */
761        public CompositionAttesterComponent setMode(List<Enumeration<CompositionAttestationMode>> theMode) { 
762          this.mode = theMode;
763          return this;
764        }
765
766        public boolean hasMode() { 
767          if (this.mode == null)
768            return false;
769          for (Enumeration<CompositionAttestationMode> item : this.mode)
770            if (!item.isEmpty())
771              return true;
772          return false;
773        }
774
775        /**
776         * @return {@link #mode} (The type of attestation the authenticator offers.)
777         */
778        public Enumeration<CompositionAttestationMode> addModeElement() {//2 
779          Enumeration<CompositionAttestationMode> t = new Enumeration<CompositionAttestationMode>(new CompositionAttestationModeEnumFactory());
780          if (this.mode == null)
781            this.mode = new ArrayList<Enumeration<CompositionAttestationMode>>();
782          this.mode.add(t);
783          return t;
784        }
785
786        /**
787         * @param value {@link #mode} (The type of attestation the authenticator offers.)
788         */
789        public CompositionAttesterComponent addMode(CompositionAttestationMode value) { //1
790          Enumeration<CompositionAttestationMode> t = new Enumeration<CompositionAttestationMode>(new CompositionAttestationModeEnumFactory());
791          t.setValue(value);
792          if (this.mode == null)
793            this.mode = new ArrayList<Enumeration<CompositionAttestationMode>>();
794          this.mode.add(t);
795          return this;
796        }
797
798        /**
799         * @param value {@link #mode} (The type of attestation the authenticator offers.)
800         */
801        public boolean hasMode(CompositionAttestationMode value) { 
802          if (this.mode == null)
803            return false;
804          for (Enumeration<CompositionAttestationMode> v : this.mode)
805            if (v.getValue().equals(value)) // code
806              return true;
807          return false;
808        }
809
810        /**
811         * @return {@link #time} (When the composition was attested by the party.). This is the underlying object with id, value and extensions. The accessor "getTime" gives direct access to the value
812         */
813        public DateTimeType getTimeElement() { 
814          if (this.time == null)
815            if (Configuration.errorOnAutoCreate())
816              throw new Error("Attempt to auto-create CompositionAttesterComponent.time");
817            else if (Configuration.doAutoCreate())
818              this.time = new DateTimeType(); // bb
819          return this.time;
820        }
821
822        public boolean hasTimeElement() { 
823          return this.time != null && !this.time.isEmpty();
824        }
825
826        public boolean hasTime() { 
827          return this.time != null && !this.time.isEmpty();
828        }
829
830        /**
831         * @param value {@link #time} (When the composition was attested by the party.). This is the underlying object with id, value and extensions. The accessor "getTime" gives direct access to the value
832         */
833        public CompositionAttesterComponent setTimeElement(DateTimeType value) { 
834          this.time = value;
835          return this;
836        }
837
838        /**
839         * @return When the composition was attested by the party.
840         */
841        public Date getTime() { 
842          return this.time == null ? null : this.time.getValue();
843        }
844
845        /**
846         * @param value When the composition was attested by the party.
847         */
848        public CompositionAttesterComponent setTime(Date value) { 
849          if (value == null)
850            this.time = null;
851          else {
852            if (this.time == null)
853              this.time = new DateTimeType();
854            this.time.setValue(value);
855          }
856          return this;
857        }
858
859        /**
860         * @return {@link #party} (Who attested the composition in the specified way.)
861         */
862        public Reference getParty() { 
863          if (this.party == null)
864            if (Configuration.errorOnAutoCreate())
865              throw new Error("Attempt to auto-create CompositionAttesterComponent.party");
866            else if (Configuration.doAutoCreate())
867              this.party = new Reference(); // cc
868          return this.party;
869        }
870
871        public boolean hasParty() { 
872          return this.party != null && !this.party.isEmpty();
873        }
874
875        /**
876         * @param value {@link #party} (Who attested the composition in the specified way.)
877         */
878        public CompositionAttesterComponent setParty(Reference value)  { 
879          this.party = value;
880          return this;
881        }
882
883        /**
884         * @return {@link #party} 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. (Who attested the composition in the specified way.)
885         */
886        public Resource getPartyTarget() { 
887          return this.partyTarget;
888        }
889
890        /**
891         * @param value {@link #party} 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. (Who attested the composition in the specified way.)
892         */
893        public CompositionAttesterComponent setPartyTarget(Resource value) { 
894          this.partyTarget = value;
895          return this;
896        }
897
898        protected void listChildren(List<Property> children) {
899          super.listChildren(children);
900          children.add(new Property("mode", "code", "The type of attestation the authenticator offers.", 0, java.lang.Integer.MAX_VALUE, mode));
901          children.add(new Property("time", "dateTime", "When the composition was attested by the party.", 0, 1, time));
902          children.add(new Property("party", "Reference(Patient|Practitioner|Organization)", "Who attested the composition in the specified way.", 0, 1, party));
903        }
904
905        @Override
906        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
907          switch (_hash) {
908          case 3357091: /*mode*/  return new Property("mode", "code", "The type of attestation the authenticator offers.", 0, java.lang.Integer.MAX_VALUE, mode);
909          case 3560141: /*time*/  return new Property("time", "dateTime", "When the composition was attested by the party.", 0, 1, time);
910          case 106437350: /*party*/  return new Property("party", "Reference(Patient|Practitioner|Organization)", "Who attested the composition in the specified way.", 0, 1, party);
911          default: return super.getNamedProperty(_hash, _name, _checkValid);
912          }
913
914        }
915
916      @Override
917      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
918        switch (hash) {
919        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : this.mode.toArray(new Base[this.mode.size()]); // Enumeration<CompositionAttestationMode>
920        case 3560141: /*time*/ return this.time == null ? new Base[0] : new Base[] {this.time}; // DateTimeType
921        case 106437350: /*party*/ return this.party == null ? new Base[0] : new Base[] {this.party}; // Reference
922        default: return super.getProperty(hash, name, checkValid);
923        }
924
925      }
926
927      @Override
928      public Base setProperty(int hash, String name, Base value) throws FHIRException {
929        switch (hash) {
930        case 3357091: // mode
931          value = new CompositionAttestationModeEnumFactory().fromType(castToCode(value));
932          this.getMode().add((Enumeration) value); // Enumeration<CompositionAttestationMode>
933          return value;
934        case 3560141: // time
935          this.time = castToDateTime(value); // DateTimeType
936          return value;
937        case 106437350: // party
938          this.party = castToReference(value); // Reference
939          return value;
940        default: return super.setProperty(hash, name, value);
941        }
942
943      }
944
945      @Override
946      public Base setProperty(String name, Base value) throws FHIRException {
947        if (name.equals("mode")) {
948          value = new CompositionAttestationModeEnumFactory().fromType(castToCode(value));
949          this.getMode().add((Enumeration) value);
950        } else if (name.equals("time")) {
951          this.time = castToDateTime(value); // DateTimeType
952        } else if (name.equals("party")) {
953          this.party = castToReference(value); // Reference
954        } else
955          return super.setProperty(name, value);
956        return value;
957      }
958
959      @Override
960      public Base makeProperty(int hash, String name) throws FHIRException {
961        switch (hash) {
962        case 3357091:  return addModeElement();
963        case 3560141:  return getTimeElement();
964        case 106437350:  return getParty(); 
965        default: return super.makeProperty(hash, name);
966        }
967
968      }
969
970      @Override
971      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
972        switch (hash) {
973        case 3357091: /*mode*/ return new String[] {"code"};
974        case 3560141: /*time*/ return new String[] {"dateTime"};
975        case 106437350: /*party*/ return new String[] {"Reference"};
976        default: return super.getTypesForProperty(hash, name);
977        }
978
979      }
980
981      @Override
982      public Base addChild(String name) throws FHIRException {
983        if (name.equals("mode")) {
984          throw new FHIRException("Cannot call addChild on a primitive type Composition.mode");
985        }
986        else if (name.equals("time")) {
987          throw new FHIRException("Cannot call addChild on a primitive type Composition.time");
988        }
989        else if (name.equals("party")) {
990          this.party = new Reference();
991          return this.party;
992        }
993        else
994          return super.addChild(name);
995      }
996
997      public CompositionAttesterComponent copy() {
998        CompositionAttesterComponent dst = new CompositionAttesterComponent();
999        copyValues(dst);
1000        if (mode != null) {
1001          dst.mode = new ArrayList<Enumeration<CompositionAttestationMode>>();
1002          for (Enumeration<CompositionAttestationMode> i : mode)
1003            dst.mode.add(i.copy());
1004        };
1005        dst.time = time == null ? null : time.copy();
1006        dst.party = party == null ? null : party.copy();
1007        return dst;
1008      }
1009
1010      @Override
1011      public boolean equalsDeep(Base other_) {
1012        if (!super.equalsDeep(other_))
1013          return false;
1014        if (!(other_ instanceof CompositionAttesterComponent))
1015          return false;
1016        CompositionAttesterComponent o = (CompositionAttesterComponent) other_;
1017        return compareDeep(mode, o.mode, true) && compareDeep(time, o.time, true) && compareDeep(party, o.party, true)
1018          ;
1019      }
1020
1021      @Override
1022      public boolean equalsShallow(Base other_) {
1023        if (!super.equalsShallow(other_))
1024          return false;
1025        if (!(other_ instanceof CompositionAttesterComponent))
1026          return false;
1027        CompositionAttesterComponent o = (CompositionAttesterComponent) other_;
1028        return compareValues(mode, o.mode, true) && compareValues(time, o.time, true);
1029      }
1030
1031      public boolean isEmpty() {
1032        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, time, party);
1033      }
1034
1035  public String fhirType() {
1036    return "Composition.attester";
1037
1038  }
1039
1040  }
1041
1042    @Block()
1043    public static class CompositionRelatesToComponent extends BackboneElement implements IBaseBackboneElement {
1044        /**
1045         * The type of relationship that this composition has with anther composition or document.
1046         */
1047        @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1048        @Description(shortDefinition="replaces | transforms | signs | appends", formalDefinition="The type of relationship that this composition has with anther composition or document." )
1049        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/document-relationship-type")
1050        protected Enumeration<DocumentRelationshipType> code;
1051
1052        /**
1053         * The target composition/document of this relationship.
1054         */
1055        @Child(name = "target", type = {Identifier.class, Composition.class}, order=2, min=1, max=1, modifier=false, summary=true)
1056        @Description(shortDefinition="Target of the relationship", formalDefinition="The target composition/document of this relationship." )
1057        protected Type target;
1058
1059        private static final long serialVersionUID = 1536930280L;
1060
1061    /**
1062     * Constructor
1063     */
1064      public CompositionRelatesToComponent() {
1065        super();
1066      }
1067
1068    /**
1069     * Constructor
1070     */
1071      public CompositionRelatesToComponent(Enumeration<DocumentRelationshipType> code, Type target) {
1072        super();
1073        this.code = code;
1074        this.target = target;
1075      }
1076
1077        /**
1078         * @return {@link #code} (The type of relationship that this composition has with anther composition or document.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1079         */
1080        public Enumeration<DocumentRelationshipType> getCodeElement() { 
1081          if (this.code == null)
1082            if (Configuration.errorOnAutoCreate())
1083              throw new Error("Attempt to auto-create CompositionRelatesToComponent.code");
1084            else if (Configuration.doAutoCreate())
1085              this.code = new Enumeration<DocumentRelationshipType>(new DocumentRelationshipTypeEnumFactory()); // bb
1086          return this.code;
1087        }
1088
1089        public boolean hasCodeElement() { 
1090          return this.code != null && !this.code.isEmpty();
1091        }
1092
1093        public boolean hasCode() { 
1094          return this.code != null && !this.code.isEmpty();
1095        }
1096
1097        /**
1098         * @param value {@link #code} (The type of relationship that this composition has with anther composition or document.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1099         */
1100        public CompositionRelatesToComponent setCodeElement(Enumeration<DocumentRelationshipType> value) { 
1101          this.code = value;
1102          return this;
1103        }
1104
1105        /**
1106         * @return The type of relationship that this composition has with anther composition or document.
1107         */
1108        public DocumentRelationshipType getCode() { 
1109          return this.code == null ? null : this.code.getValue();
1110        }
1111
1112        /**
1113         * @param value The type of relationship that this composition has with anther composition or document.
1114         */
1115        public CompositionRelatesToComponent setCode(DocumentRelationshipType value) { 
1116            if (this.code == null)
1117              this.code = new Enumeration<DocumentRelationshipType>(new DocumentRelationshipTypeEnumFactory());
1118            this.code.setValue(value);
1119          return this;
1120        }
1121
1122        /**
1123         * @return {@link #target} (The target composition/document of this relationship.)
1124         */
1125        public Type getTarget() { 
1126          return this.target;
1127        }
1128
1129        /**
1130         * @return {@link #target} (The target composition/document of this relationship.)
1131         */
1132        public Identifier getTargetIdentifier() throws FHIRException { 
1133          if (this.target == null)
1134            return null;
1135          if (!(this.target instanceof Identifier))
1136            throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.target.getClass().getName()+" was encountered");
1137          return (Identifier) this.target;
1138        }
1139
1140        public boolean hasTargetIdentifier() { 
1141          return this != null && this.target instanceof Identifier;
1142        }
1143
1144        /**
1145         * @return {@link #target} (The target composition/document of this relationship.)
1146         */
1147        public Reference getTargetReference() throws FHIRException { 
1148          if (this.target == null)
1149            return null;
1150          if (!(this.target instanceof Reference))
1151            throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.target.getClass().getName()+" was encountered");
1152          return (Reference) this.target;
1153        }
1154
1155        public boolean hasTargetReference() { 
1156          return this != null && this.target instanceof Reference;
1157        }
1158
1159        public boolean hasTarget() { 
1160          return this.target != null && !this.target.isEmpty();
1161        }
1162
1163        /**
1164         * @param value {@link #target} (The target composition/document of this relationship.)
1165         */
1166        public CompositionRelatesToComponent setTarget(Type value) throws FHIRFormatError { 
1167          if (value != null && !(value instanceof Identifier || value instanceof Reference))
1168            throw new FHIRFormatError("Not the right type for Composition.relatesTo.target[x]: "+value.fhirType());
1169          this.target = value;
1170          return this;
1171        }
1172
1173        protected void listChildren(List<Property> children) {
1174          super.listChildren(children);
1175          children.add(new Property("code", "code", "The type of relationship that this composition has with anther composition or document.", 0, 1, code));
1176          children.add(new Property("target[x]", "Identifier|Reference(Composition)", "The target composition/document of this relationship.", 0, 1, target));
1177        }
1178
1179        @Override
1180        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1181          switch (_hash) {
1182          case 3059181: /*code*/  return new Property("code", "code", "The type of relationship that this composition has with anther composition or document.", 0, 1, code);
1183          case -815579825: /*target[x]*/  return new Property("target[x]", "Identifier|Reference(Composition)", "The target composition/document of this relationship.", 0, 1, target);
1184          case -880905839: /*target*/  return new Property("target[x]", "Identifier|Reference(Composition)", "The target composition/document of this relationship.", 0, 1, target);
1185          case 1690892570: /*targetIdentifier*/  return new Property("target[x]", "Identifier|Reference(Composition)", "The target composition/document of this relationship.", 0, 1, target);
1186          case 1259806906: /*targetReference*/  return new Property("target[x]", "Identifier|Reference(Composition)", "The target composition/document of this relationship.", 0, 1, target);
1187          default: return super.getNamedProperty(_hash, _name, _checkValid);
1188          }
1189
1190        }
1191
1192      @Override
1193      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1194        switch (hash) {
1195        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<DocumentRelationshipType>
1196        case -880905839: /*target*/ return this.target == null ? new Base[0] : new Base[] {this.target}; // Type
1197        default: return super.getProperty(hash, name, checkValid);
1198        }
1199
1200      }
1201
1202      @Override
1203      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1204        switch (hash) {
1205        case 3059181: // code
1206          value = new DocumentRelationshipTypeEnumFactory().fromType(castToCode(value));
1207          this.code = (Enumeration) value; // Enumeration<DocumentRelationshipType>
1208          return value;
1209        case -880905839: // target
1210          this.target = castToType(value); // Type
1211          return value;
1212        default: return super.setProperty(hash, name, value);
1213        }
1214
1215      }
1216
1217      @Override
1218      public Base setProperty(String name, Base value) throws FHIRException {
1219        if (name.equals("code")) {
1220          value = new DocumentRelationshipTypeEnumFactory().fromType(castToCode(value));
1221          this.code = (Enumeration) value; // Enumeration<DocumentRelationshipType>
1222        } else if (name.equals("target[x]")) {
1223          this.target = castToType(value); // Type
1224        } else
1225          return super.setProperty(name, value);
1226        return value;
1227      }
1228
1229      @Override
1230      public Base makeProperty(int hash, String name) throws FHIRException {
1231        switch (hash) {
1232        case 3059181:  return getCodeElement();
1233        case -815579825:  return getTarget(); 
1234        case -880905839:  return getTarget(); 
1235        default: return super.makeProperty(hash, name);
1236        }
1237
1238      }
1239
1240      @Override
1241      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1242        switch (hash) {
1243        case 3059181: /*code*/ return new String[] {"code"};
1244        case -880905839: /*target*/ return new String[] {"Identifier", "Reference"};
1245        default: return super.getTypesForProperty(hash, name);
1246        }
1247
1248      }
1249
1250      @Override
1251      public Base addChild(String name) throws FHIRException {
1252        if (name.equals("code")) {
1253          throw new FHIRException("Cannot call addChild on a primitive type Composition.code");
1254        }
1255        else if (name.equals("targetIdentifier")) {
1256          this.target = new Identifier();
1257          return this.target;
1258        }
1259        else if (name.equals("targetReference")) {
1260          this.target = new Reference();
1261          return this.target;
1262        }
1263        else
1264          return super.addChild(name);
1265      }
1266
1267      public CompositionRelatesToComponent copy() {
1268        CompositionRelatesToComponent dst = new CompositionRelatesToComponent();
1269        copyValues(dst);
1270        dst.code = code == null ? null : code.copy();
1271        dst.target = target == null ? null : target.copy();
1272        return dst;
1273      }
1274
1275      @Override
1276      public boolean equalsDeep(Base other_) {
1277        if (!super.equalsDeep(other_))
1278          return false;
1279        if (!(other_ instanceof CompositionRelatesToComponent))
1280          return false;
1281        CompositionRelatesToComponent o = (CompositionRelatesToComponent) other_;
1282        return compareDeep(code, o.code, true) && compareDeep(target, o.target, true);
1283      }
1284
1285      @Override
1286      public boolean equalsShallow(Base other_) {
1287        if (!super.equalsShallow(other_))
1288          return false;
1289        if (!(other_ instanceof CompositionRelatesToComponent))
1290          return false;
1291        CompositionRelatesToComponent o = (CompositionRelatesToComponent) other_;
1292        return compareValues(code, o.code, true);
1293      }
1294
1295      public boolean isEmpty() {
1296        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, target);
1297      }
1298
1299  public String fhirType() {
1300    return "Composition.relatesTo";
1301
1302  }
1303
1304  }
1305
1306    @Block()
1307    public static class CompositionEventComponent extends BackboneElement implements IBaseBackboneElement {
1308        /**
1309         * This list of codes represents the main clinical acts, such as a colonoscopy or an appendectomy, being documented. In some cases, the event is inherent in the typeCode, such as a "History and Physical Report" in which the procedure being documented is necessarily a "History and Physical" act.
1310         */
1311        @Child(name = "code", type = {CodeableConcept.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1312        @Description(shortDefinition="Code(s) that apply to the event being documented", formalDefinition="This list of codes represents the main clinical acts, such as a colonoscopy or an appendectomy, being documented. In some cases, the event is inherent in the typeCode, such as a \"History and Physical Report\" in which the procedure being documented is necessarily a \"History and Physical\" act." )
1313        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v3-ActCode")
1314        protected List<CodeableConcept> code;
1315
1316        /**
1317         * The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time.
1318         */
1319        @Child(name = "period", type = {Period.class}, order=2, min=0, max=1, modifier=false, summary=true)
1320        @Description(shortDefinition="The period covered by the documentation", formalDefinition="The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time." )
1321        protected Period period;
1322
1323        /**
1324         * The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy.
1325         */
1326        @Child(name = "detail", type = {Reference.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1327        @Description(shortDefinition="The event(s) being documented", formalDefinition="The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy." )
1328        protected List<Reference> detail;
1329        /**
1330         * The actual objects that are the target of the reference (The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy.)
1331         */
1332        protected List<Resource> detailTarget;
1333
1334
1335        private static final long serialVersionUID = -1581379774L;
1336
1337    /**
1338     * Constructor
1339     */
1340      public CompositionEventComponent() {
1341        super();
1342      }
1343
1344        /**
1345         * @return {@link #code} (This list of codes represents the main clinical acts, such as a colonoscopy or an appendectomy, being documented. In some cases, the event is inherent in the typeCode, such as a "History and Physical Report" in which the procedure being documented is necessarily a "History and Physical" act.)
1346         */
1347        public List<CodeableConcept> getCode() { 
1348          if (this.code == null)
1349            this.code = new ArrayList<CodeableConcept>();
1350          return this.code;
1351        }
1352
1353        /**
1354         * @return Returns a reference to <code>this</code> for easy method chaining
1355         */
1356        public CompositionEventComponent setCode(List<CodeableConcept> theCode) { 
1357          this.code = theCode;
1358          return this;
1359        }
1360
1361        public boolean hasCode() { 
1362          if (this.code == null)
1363            return false;
1364          for (CodeableConcept item : this.code)
1365            if (!item.isEmpty())
1366              return true;
1367          return false;
1368        }
1369
1370        public CodeableConcept addCode() { //3
1371          CodeableConcept t = new CodeableConcept();
1372          if (this.code == null)
1373            this.code = new ArrayList<CodeableConcept>();
1374          this.code.add(t);
1375          return t;
1376        }
1377
1378        public CompositionEventComponent addCode(CodeableConcept t) { //3
1379          if (t == null)
1380            return this;
1381          if (this.code == null)
1382            this.code = new ArrayList<CodeableConcept>();
1383          this.code.add(t);
1384          return this;
1385        }
1386
1387        /**
1388         * @return The first repetition of repeating field {@link #code}, creating it if it does not already exist
1389         */
1390        public CodeableConcept getCodeFirstRep() { 
1391          if (getCode().isEmpty()) {
1392            addCode();
1393          }
1394          return getCode().get(0);
1395        }
1396
1397        /**
1398         * @return {@link #period} (The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time.)
1399         */
1400        public Period getPeriod() { 
1401          if (this.period == null)
1402            if (Configuration.errorOnAutoCreate())
1403              throw new Error("Attempt to auto-create CompositionEventComponent.period");
1404            else if (Configuration.doAutoCreate())
1405              this.period = new Period(); // cc
1406          return this.period;
1407        }
1408
1409        public boolean hasPeriod() { 
1410          return this.period != null && !this.period.isEmpty();
1411        }
1412
1413        /**
1414         * @param value {@link #period} (The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time.)
1415         */
1416        public CompositionEventComponent setPeriod(Period value)  { 
1417          this.period = value;
1418          return this;
1419        }
1420
1421        /**
1422         * @return {@link #detail} (The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy.)
1423         */
1424        public List<Reference> getDetail() { 
1425          if (this.detail == null)
1426            this.detail = new ArrayList<Reference>();
1427          return this.detail;
1428        }
1429
1430        /**
1431         * @return Returns a reference to <code>this</code> for easy method chaining
1432         */
1433        public CompositionEventComponent setDetail(List<Reference> theDetail) { 
1434          this.detail = theDetail;
1435          return this;
1436        }
1437
1438        public boolean hasDetail() { 
1439          if (this.detail == null)
1440            return false;
1441          for (Reference item : this.detail)
1442            if (!item.isEmpty())
1443              return true;
1444          return false;
1445        }
1446
1447        public Reference addDetail() { //3
1448          Reference t = new Reference();
1449          if (this.detail == null)
1450            this.detail = new ArrayList<Reference>();
1451          this.detail.add(t);
1452          return t;
1453        }
1454
1455        public CompositionEventComponent addDetail(Reference t) { //3
1456          if (t == null)
1457            return this;
1458          if (this.detail == null)
1459            this.detail = new ArrayList<Reference>();
1460          this.detail.add(t);
1461          return this;
1462        }
1463
1464        /**
1465         * @return The first repetition of repeating field {@link #detail}, creating it if it does not already exist
1466         */
1467        public Reference getDetailFirstRep() { 
1468          if (getDetail().isEmpty()) {
1469            addDetail();
1470          }
1471          return getDetail().get(0);
1472        }
1473
1474        /**
1475         * @deprecated Use Reference#setResource(IBaseResource) instead
1476         */
1477        @Deprecated
1478        public List<Resource> getDetailTarget() { 
1479          if (this.detailTarget == null)
1480            this.detailTarget = new ArrayList<Resource>();
1481          return this.detailTarget;
1482        }
1483
1484        protected void listChildren(List<Property> children) {
1485          super.listChildren(children);
1486          children.add(new Property("code", "CodeableConcept", "This list of codes represents the main clinical acts, such as a colonoscopy or an appendectomy, being documented. In some cases, the event is inherent in the typeCode, such as a \"History and Physical Report\" in which the procedure being documented is necessarily a \"History and Physical\" act.", 0, java.lang.Integer.MAX_VALUE, code));
1487          children.add(new Property("period", "Period", "The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time.", 0, 1, period));
1488          children.add(new Property("detail", "Reference(Any)", "The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy.", 0, java.lang.Integer.MAX_VALUE, detail));
1489        }
1490
1491        @Override
1492        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1493          switch (_hash) {
1494          case 3059181: /*code*/  return new Property("code", "CodeableConcept", "This list of codes represents the main clinical acts, such as a colonoscopy or an appendectomy, being documented. In some cases, the event is inherent in the typeCode, such as a \"History and Physical Report\" in which the procedure being documented is necessarily a \"History and Physical\" act.", 0, java.lang.Integer.MAX_VALUE, code);
1495          case -991726143: /*period*/  return new Property("period", "Period", "The period of time covered by the documentation. There is no assertion that the documentation is a complete representation for this period, only that it documents events during this time.", 0, 1, period);
1496          case -1335224239: /*detail*/  return new Property("detail", "Reference(Any)", "The description and/or reference of the event(s) being documented. For example, this could be used to document such a colonoscopy or an appendectomy.", 0, java.lang.Integer.MAX_VALUE, detail);
1497          default: return super.getNamedProperty(_hash, _name, _checkValid);
1498          }
1499
1500        }
1501
1502      @Override
1503      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1504        switch (hash) {
1505        case 3059181: /*code*/ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // CodeableConcept
1506        case -991726143: /*period*/ return this.period == null ? new Base[0] : new Base[] {this.period}; // Period
1507        case -1335224239: /*detail*/ return this.detail == null ? new Base[0] : this.detail.toArray(new Base[this.detail.size()]); // Reference
1508        default: return super.getProperty(hash, name, checkValid);
1509        }
1510
1511      }
1512
1513      @Override
1514      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1515        switch (hash) {
1516        case 3059181: // code
1517          this.getCode().add(castToCodeableConcept(value)); // CodeableConcept
1518          return value;
1519        case -991726143: // period
1520          this.period = castToPeriod(value); // Period
1521          return value;
1522        case -1335224239: // detail
1523          this.getDetail().add(castToReference(value)); // Reference
1524          return value;
1525        default: return super.setProperty(hash, name, value);
1526        }
1527
1528      }
1529
1530      @Override
1531      public Base setProperty(String name, Base value) throws FHIRException {
1532        if (name.equals("code")) {
1533          this.getCode().add(castToCodeableConcept(value));
1534        } else if (name.equals("period")) {
1535          this.period = castToPeriod(value); // Period
1536        } else if (name.equals("detail")) {
1537          this.getDetail().add(castToReference(value));
1538        } else
1539          return super.setProperty(name, value);
1540        return value;
1541      }
1542
1543      @Override
1544      public Base makeProperty(int hash, String name) throws FHIRException {
1545        switch (hash) {
1546        case 3059181:  return addCode(); 
1547        case -991726143:  return getPeriod(); 
1548        case -1335224239:  return addDetail(); 
1549        default: return super.makeProperty(hash, name);
1550        }
1551
1552      }
1553
1554      @Override
1555      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1556        switch (hash) {
1557        case 3059181: /*code*/ return new String[] {"CodeableConcept"};
1558        case -991726143: /*period*/ return new String[] {"Period"};
1559        case -1335224239: /*detail*/ return new String[] {"Reference"};
1560        default: return super.getTypesForProperty(hash, name);
1561        }
1562
1563      }
1564
1565      @Override
1566      public Base addChild(String name) throws FHIRException {
1567        if (name.equals("code")) {
1568          return addCode();
1569        }
1570        else if (name.equals("period")) {
1571          this.period = new Period();
1572          return this.period;
1573        }
1574        else if (name.equals("detail")) {
1575          return addDetail();
1576        }
1577        else
1578          return super.addChild(name);
1579      }
1580
1581      public CompositionEventComponent copy() {
1582        CompositionEventComponent dst = new CompositionEventComponent();
1583        copyValues(dst);
1584        if (code != null) {
1585          dst.code = new ArrayList<CodeableConcept>();
1586          for (CodeableConcept i : code)
1587            dst.code.add(i.copy());
1588        };
1589        dst.period = period == null ? null : period.copy();
1590        if (detail != null) {
1591          dst.detail = new ArrayList<Reference>();
1592          for (Reference i : detail)
1593            dst.detail.add(i.copy());
1594        };
1595        return dst;
1596      }
1597
1598      @Override
1599      public boolean equalsDeep(Base other_) {
1600        if (!super.equalsDeep(other_))
1601          return false;
1602        if (!(other_ instanceof CompositionEventComponent))
1603          return false;
1604        CompositionEventComponent o = (CompositionEventComponent) other_;
1605        return compareDeep(code, o.code, true) && compareDeep(period, o.period, true) && compareDeep(detail, o.detail, true)
1606          ;
1607      }
1608
1609      @Override
1610      public boolean equalsShallow(Base other_) {
1611        if (!super.equalsShallow(other_))
1612          return false;
1613        if (!(other_ instanceof CompositionEventComponent))
1614          return false;
1615        CompositionEventComponent o = (CompositionEventComponent) other_;
1616        return true;
1617      }
1618
1619      public boolean isEmpty() {
1620        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, period, detail);
1621      }
1622
1623  public String fhirType() {
1624    return "Composition.event";
1625
1626  }
1627
1628  }
1629
1630    @Block()
1631    public static class SectionComponent extends BackboneElement implements IBaseBackboneElement {
1632        /**
1633         * The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.
1634         */
1635        @Child(name = "title", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
1636        @Description(shortDefinition="Label for section (e.g. for ToC)", formalDefinition="The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents." )
1637        protected StringType title;
1638
1639        /**
1640         * A code identifying the kind of content contained within the section. This must be consistent with the section title.
1641         */
1642        @Child(name = "code", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false)
1643        @Description(shortDefinition="Classification of section (recommended)", formalDefinition="A code identifying the kind of content contained within the section. This must be consistent with the section title." )
1644        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/doc-section-codes")
1645        protected CodeableConcept code;
1646
1647        /**
1648         * A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative.
1649         */
1650        @Child(name = "text", type = {Narrative.class}, order=3, min=0, max=1, modifier=false, summary=false)
1651        @Description(shortDefinition="Text summary of the section, for human interpretation", formalDefinition="A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative." )
1652        protected Narrative text;
1653
1654        /**
1655         * How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.
1656         */
1657        @Child(name = "mode", type = {CodeType.class}, order=4, min=0, max=1, modifier=true, summary=true)
1658        @Description(shortDefinition="working | snapshot | changes", formalDefinition="How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted." )
1659        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/list-mode")
1660        protected Enumeration<SectionMode> mode;
1661
1662        /**
1663         * Specifies the order applied to the items in the section entries.
1664         */
1665        @Child(name = "orderedBy", type = {CodeableConcept.class}, order=5, min=0, max=1, modifier=false, summary=false)
1666        @Description(shortDefinition="Order of section entries", formalDefinition="Specifies the order applied to the items in the section entries." )
1667        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/list-order")
1668        protected CodeableConcept orderedBy;
1669
1670        /**
1671         * A reference to the actual resource from which the narrative in the section is derived.
1672         */
1673        @Child(name = "entry", type = {Reference.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1674        @Description(shortDefinition="A reference to data that supports this section", formalDefinition="A reference to the actual resource from which the narrative in the section is derived." )
1675        protected List<Reference> entry;
1676        /**
1677         * The actual objects that are the target of the reference (A reference to the actual resource from which the narrative in the section is derived.)
1678         */
1679        protected List<Resource> entryTarget;
1680
1681
1682        /**
1683         * If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason.
1684         */
1685        @Child(name = "emptyReason", type = {CodeableConcept.class}, order=7, min=0, max=1, modifier=false, summary=false)
1686        @Description(shortDefinition="Why the section is empty", formalDefinition="If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason." )
1687        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/list-empty-reason")
1688        protected CodeableConcept emptyReason;
1689
1690        /**
1691         * A nested sub-section within this section.
1692         */
1693        @Child(name = "section", type = {SectionComponent.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1694        @Description(shortDefinition="Nested Section", formalDefinition="A nested sub-section within this section." )
1695        protected List<SectionComponent> section;
1696
1697        private static final long serialVersionUID = -128426142L;
1698
1699    /**
1700     * Constructor
1701     */
1702      public SectionComponent() {
1703        super();
1704      }
1705
1706        /**
1707         * @return {@link #title} (The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1708         */
1709        public StringType getTitleElement() { 
1710          if (this.title == null)
1711            if (Configuration.errorOnAutoCreate())
1712              throw new Error("Attempt to auto-create SectionComponent.title");
1713            else if (Configuration.doAutoCreate())
1714              this.title = new StringType(); // bb
1715          return this.title;
1716        }
1717
1718        public boolean hasTitleElement() { 
1719          return this.title != null && !this.title.isEmpty();
1720        }
1721
1722        public boolean hasTitle() { 
1723          return this.title != null && !this.title.isEmpty();
1724        }
1725
1726        /**
1727         * @param value {@link #title} (The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1728         */
1729        public SectionComponent setTitleElement(StringType value) { 
1730          this.title = value;
1731          return this;
1732        }
1733
1734        /**
1735         * @return The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.
1736         */
1737        public String getTitle() { 
1738          return this.title == null ? null : this.title.getValue();
1739        }
1740
1741        /**
1742         * @param value The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.
1743         */
1744        public SectionComponent setTitle(String value) { 
1745          if (Utilities.noString(value))
1746            this.title = null;
1747          else {
1748            if (this.title == null)
1749              this.title = new StringType();
1750            this.title.setValue(value);
1751          }
1752          return this;
1753        }
1754
1755        /**
1756         * @return {@link #code} (A code identifying the kind of content contained within the section. This must be consistent with the section title.)
1757         */
1758        public CodeableConcept getCode() { 
1759          if (this.code == null)
1760            if (Configuration.errorOnAutoCreate())
1761              throw new Error("Attempt to auto-create SectionComponent.code");
1762            else if (Configuration.doAutoCreate())
1763              this.code = new CodeableConcept(); // cc
1764          return this.code;
1765        }
1766
1767        public boolean hasCode() { 
1768          return this.code != null && !this.code.isEmpty();
1769        }
1770
1771        /**
1772         * @param value {@link #code} (A code identifying the kind of content contained within the section. This must be consistent with the section title.)
1773         */
1774        public SectionComponent setCode(CodeableConcept value)  { 
1775          this.code = value;
1776          return this;
1777        }
1778
1779        /**
1780         * @return {@link #text} (A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative.)
1781         */
1782        public Narrative getText() { 
1783          if (this.text == null)
1784            if (Configuration.errorOnAutoCreate())
1785              throw new Error("Attempt to auto-create SectionComponent.text");
1786            else if (Configuration.doAutoCreate())
1787              this.text = new Narrative(); // cc
1788          return this.text;
1789        }
1790
1791        public boolean hasText() { 
1792          return this.text != null && !this.text.isEmpty();
1793        }
1794
1795        /**
1796         * @param value {@link #text} (A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative.)
1797         */
1798        public SectionComponent setText(Narrative value)  { 
1799          this.text = value;
1800          return this;
1801        }
1802
1803        /**
1804         * @return {@link #mode} (How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
1805         */
1806        public Enumeration<SectionMode> getModeElement() { 
1807          if (this.mode == null)
1808            if (Configuration.errorOnAutoCreate())
1809              throw new Error("Attempt to auto-create SectionComponent.mode");
1810            else if (Configuration.doAutoCreate())
1811              this.mode = new Enumeration<SectionMode>(new SectionModeEnumFactory()); // bb
1812          return this.mode;
1813        }
1814
1815        public boolean hasModeElement() { 
1816          return this.mode != null && !this.mode.isEmpty();
1817        }
1818
1819        public boolean hasMode() { 
1820          return this.mode != null && !this.mode.isEmpty();
1821        }
1822
1823        /**
1824         * @param value {@link #mode} (How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
1825         */
1826        public SectionComponent setModeElement(Enumeration<SectionMode> value) { 
1827          this.mode = value;
1828          return this;
1829        }
1830
1831        /**
1832         * @return How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.
1833         */
1834        public SectionMode getMode() { 
1835          return this.mode == null ? null : this.mode.getValue();
1836        }
1837
1838        /**
1839         * @param value How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.
1840         */
1841        public SectionComponent setMode(SectionMode value) { 
1842          if (value == null)
1843            this.mode = null;
1844          else {
1845            if (this.mode == null)
1846              this.mode = new Enumeration<SectionMode>(new SectionModeEnumFactory());
1847            this.mode.setValue(value);
1848          }
1849          return this;
1850        }
1851
1852        /**
1853         * @return {@link #orderedBy} (Specifies the order applied to the items in the section entries.)
1854         */
1855        public CodeableConcept getOrderedBy() { 
1856          if (this.orderedBy == null)
1857            if (Configuration.errorOnAutoCreate())
1858              throw new Error("Attempt to auto-create SectionComponent.orderedBy");
1859            else if (Configuration.doAutoCreate())
1860              this.orderedBy = new CodeableConcept(); // cc
1861          return this.orderedBy;
1862        }
1863
1864        public boolean hasOrderedBy() { 
1865          return this.orderedBy != null && !this.orderedBy.isEmpty();
1866        }
1867
1868        /**
1869         * @param value {@link #orderedBy} (Specifies the order applied to the items in the section entries.)
1870         */
1871        public SectionComponent setOrderedBy(CodeableConcept value)  { 
1872          this.orderedBy = value;
1873          return this;
1874        }
1875
1876        /**
1877         * @return {@link #entry} (A reference to the actual resource from which the narrative in the section is derived.)
1878         */
1879        public List<Reference> getEntry() { 
1880          if (this.entry == null)
1881            this.entry = new ArrayList<Reference>();
1882          return this.entry;
1883        }
1884
1885        /**
1886         * @return Returns a reference to <code>this</code> for easy method chaining
1887         */
1888        public SectionComponent setEntry(List<Reference> theEntry) { 
1889          this.entry = theEntry;
1890          return this;
1891        }
1892
1893        public boolean hasEntry() { 
1894          if (this.entry == null)
1895            return false;
1896          for (Reference item : this.entry)
1897            if (!item.isEmpty())
1898              return true;
1899          return false;
1900        }
1901
1902        public Reference addEntry() { //3
1903          Reference t = new Reference();
1904          if (this.entry == null)
1905            this.entry = new ArrayList<Reference>();
1906          this.entry.add(t);
1907          return t;
1908        }
1909
1910        public SectionComponent addEntry(Reference t) { //3
1911          if (t == null)
1912            return this;
1913          if (this.entry == null)
1914            this.entry = new ArrayList<Reference>();
1915          this.entry.add(t);
1916          return this;
1917        }
1918
1919        /**
1920         * @return The first repetition of repeating field {@link #entry}, creating it if it does not already exist
1921         */
1922        public Reference getEntryFirstRep() { 
1923          if (getEntry().isEmpty()) {
1924            addEntry();
1925          }
1926          return getEntry().get(0);
1927        }
1928
1929        /**
1930         * @deprecated Use Reference#setResource(IBaseResource) instead
1931         */
1932        @Deprecated
1933        public List<Resource> getEntryTarget() { 
1934          if (this.entryTarget == null)
1935            this.entryTarget = new ArrayList<Resource>();
1936          return this.entryTarget;
1937        }
1938
1939        /**
1940         * @return {@link #emptyReason} (If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason.)
1941         */
1942        public CodeableConcept getEmptyReason() { 
1943          if (this.emptyReason == null)
1944            if (Configuration.errorOnAutoCreate())
1945              throw new Error("Attempt to auto-create SectionComponent.emptyReason");
1946            else if (Configuration.doAutoCreate())
1947              this.emptyReason = new CodeableConcept(); // cc
1948          return this.emptyReason;
1949        }
1950
1951        public boolean hasEmptyReason() { 
1952          return this.emptyReason != null && !this.emptyReason.isEmpty();
1953        }
1954
1955        /**
1956         * @param value {@link #emptyReason} (If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason.)
1957         */
1958        public SectionComponent setEmptyReason(CodeableConcept value)  { 
1959          this.emptyReason = value;
1960          return this;
1961        }
1962
1963        /**
1964         * @return {@link #section} (A nested sub-section within this section.)
1965         */
1966        public List<SectionComponent> getSection() { 
1967          if (this.section == null)
1968            this.section = new ArrayList<SectionComponent>();
1969          return this.section;
1970        }
1971
1972        /**
1973         * @return Returns a reference to <code>this</code> for easy method chaining
1974         */
1975        public SectionComponent setSection(List<SectionComponent> theSection) { 
1976          this.section = theSection;
1977          return this;
1978        }
1979
1980        public boolean hasSection() { 
1981          if (this.section == null)
1982            return false;
1983          for (SectionComponent item : this.section)
1984            if (!item.isEmpty())
1985              return true;
1986          return false;
1987        }
1988
1989        public SectionComponent addSection() { //3
1990          SectionComponent t = new SectionComponent();
1991          if (this.section == null)
1992            this.section = new ArrayList<SectionComponent>();
1993          this.section.add(t);
1994          return t;
1995        }
1996
1997        public SectionComponent addSection(SectionComponent t) { //3
1998          if (t == null)
1999            return this;
2000          if (this.section == null)
2001            this.section = new ArrayList<SectionComponent>();
2002          this.section.add(t);
2003          return this;
2004        }
2005
2006        /**
2007         * @return The first repetition of repeating field {@link #section}, creating it if it does not already exist
2008         */
2009        public SectionComponent getSectionFirstRep() { 
2010          if (getSection().isEmpty()) {
2011            addSection();
2012          }
2013          return getSection().get(0);
2014        }
2015
2016        protected void listChildren(List<Property> children) {
2017          super.listChildren(children);
2018          children.add(new Property("title", "string", "The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.", 0, 1, title));
2019          children.add(new Property("code", "CodeableConcept", "A code identifying the kind of content contained within the section. This must be consistent with the section title.", 0, 1, code));
2020          children.add(new Property("text", "Narrative", "A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative.", 0, 1, text));
2021          children.add(new Property("mode", "code", "How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.", 0, 1, mode));
2022          children.add(new Property("orderedBy", "CodeableConcept", "Specifies the order applied to the items in the section entries.", 0, 1, orderedBy));
2023          children.add(new Property("entry", "Reference(Any)", "A reference to the actual resource from which the narrative in the section is derived.", 0, java.lang.Integer.MAX_VALUE, entry));
2024          children.add(new Property("emptyReason", "CodeableConcept", "If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason.", 0, 1, emptyReason));
2025          children.add(new Property("section", "@Composition.section", "A nested sub-section within this section.", 0, java.lang.Integer.MAX_VALUE, section));
2026        }
2027
2028        @Override
2029        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2030          switch (_hash) {
2031          case 110371416: /*title*/  return new Property("title", "string", "The label for this particular section.  This will be part of the rendered content for the document, and is often used to build a table of contents.", 0, 1, title);
2032          case 3059181: /*code*/  return new Property("code", "CodeableConcept", "A code identifying the kind of content contained within the section. This must be consistent with the section title.", 0, 1, code);
2033          case 3556653: /*text*/  return new Property("text", "Narrative", "A human-readable narrative that contains the attested content of the section, used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative.", 0, 1, text);
2034          case 3357091: /*mode*/  return new Property("mode", "code", "How the entry list was prepared - whether it is a working list that is suitable for being maintained on an ongoing basis, or if it represents a snapshot of a list of items from another source, or whether it is a prepared list where items may be marked as added, modified or deleted.", 0, 1, mode);
2035          case -391079516: /*orderedBy*/  return new Property("orderedBy", "CodeableConcept", "Specifies the order applied to the items in the section entries.", 0, 1, orderedBy);
2036          case 96667762: /*entry*/  return new Property("entry", "Reference(Any)", "A reference to the actual resource from which the narrative in the section is derived.", 0, java.lang.Integer.MAX_VALUE, entry);
2037          case 1140135409: /*emptyReason*/  return new Property("emptyReason", "CodeableConcept", "If the section is empty, why the list is empty. An empty section typically has some text explaining the empty reason.", 0, 1, emptyReason);
2038          case 1970241253: /*section*/  return new Property("section", "@Composition.section", "A nested sub-section within this section.", 0, java.lang.Integer.MAX_VALUE, section);
2039          default: return super.getNamedProperty(_hash, _name, _checkValid);
2040          }
2041
2042        }
2043
2044      @Override
2045      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2046        switch (hash) {
2047        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
2048        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept
2049        case 3556653: /*text*/ return this.text == null ? new Base[0] : new Base[] {this.text}; // Narrative
2050        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<SectionMode>
2051        case -391079516: /*orderedBy*/ return this.orderedBy == null ? new Base[0] : new Base[] {this.orderedBy}; // CodeableConcept
2052        case 96667762: /*entry*/ return this.entry == null ? new Base[0] : this.entry.toArray(new Base[this.entry.size()]); // Reference
2053        case 1140135409: /*emptyReason*/ return this.emptyReason == null ? new Base[0] : new Base[] {this.emptyReason}; // CodeableConcept
2054        case 1970241253: /*section*/ return this.section == null ? new Base[0] : this.section.toArray(new Base[this.section.size()]); // SectionComponent
2055        default: return super.getProperty(hash, name, checkValid);
2056        }
2057
2058      }
2059
2060      @Override
2061      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2062        switch (hash) {
2063        case 110371416: // title
2064          this.title = castToString(value); // StringType
2065          return value;
2066        case 3059181: // code
2067          this.code = castToCodeableConcept(value); // CodeableConcept
2068          return value;
2069        case 3556653: // text
2070          this.text = castToNarrative(value); // Narrative
2071          return value;
2072        case 3357091: // mode
2073          value = new SectionModeEnumFactory().fromType(castToCode(value));
2074          this.mode = (Enumeration) value; // Enumeration<SectionMode>
2075          return value;
2076        case -391079516: // orderedBy
2077          this.orderedBy = castToCodeableConcept(value); // CodeableConcept
2078          return value;
2079        case 96667762: // entry
2080          this.getEntry().add(castToReference(value)); // Reference
2081          return value;
2082        case 1140135409: // emptyReason
2083          this.emptyReason = castToCodeableConcept(value); // CodeableConcept
2084          return value;
2085        case 1970241253: // section
2086          this.getSection().add((SectionComponent) value); // SectionComponent
2087          return value;
2088        default: return super.setProperty(hash, name, value);
2089        }
2090
2091      }
2092
2093      @Override
2094      public Base setProperty(String name, Base value) throws FHIRException {
2095        if (name.equals("title")) {
2096          this.title = castToString(value); // StringType
2097        } else if (name.equals("code")) {
2098          this.code = castToCodeableConcept(value); // CodeableConcept
2099        } else if (name.equals("text")) {
2100          this.text = castToNarrative(value); // Narrative
2101        } else if (name.equals("mode")) {
2102          value = new SectionModeEnumFactory().fromType(castToCode(value));
2103          this.mode = (Enumeration) value; // Enumeration<SectionMode>
2104        } else if (name.equals("orderedBy")) {
2105          this.orderedBy = castToCodeableConcept(value); // CodeableConcept
2106        } else if (name.equals("entry")) {
2107          this.getEntry().add(castToReference(value));
2108        } else if (name.equals("emptyReason")) {
2109          this.emptyReason = castToCodeableConcept(value); // CodeableConcept
2110        } else if (name.equals("section")) {
2111          this.getSection().add((SectionComponent) value);
2112        } else
2113          return super.setProperty(name, value);
2114        return value;
2115      }
2116
2117      @Override
2118      public Base makeProperty(int hash, String name) throws FHIRException {
2119        switch (hash) {
2120        case 110371416:  return getTitleElement();
2121        case 3059181:  return getCode(); 
2122        case 3556653:  return getText(); 
2123        case 3357091:  return getModeElement();
2124        case -391079516:  return getOrderedBy(); 
2125        case 96667762:  return addEntry(); 
2126        case 1140135409:  return getEmptyReason(); 
2127        case 1970241253:  return addSection(); 
2128        default: return super.makeProperty(hash, name);
2129        }
2130
2131      }
2132
2133      @Override
2134      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2135        switch (hash) {
2136        case 110371416: /*title*/ return new String[] {"string"};
2137        case 3059181: /*code*/ return new String[] {"CodeableConcept"};
2138        case 3556653: /*text*/ return new String[] {"Narrative"};
2139        case 3357091: /*mode*/ return new String[] {"code"};
2140        case -391079516: /*orderedBy*/ return new String[] {"CodeableConcept"};
2141        case 96667762: /*entry*/ return new String[] {"Reference"};
2142        case 1140135409: /*emptyReason*/ return new String[] {"CodeableConcept"};
2143        case 1970241253: /*section*/ return new String[] {"@Composition.section"};
2144        default: return super.getTypesForProperty(hash, name);
2145        }
2146
2147      }
2148
2149      @Override
2150      public Base addChild(String name) throws FHIRException {
2151        if (name.equals("title")) {
2152          throw new FHIRException("Cannot call addChild on a primitive type Composition.title");
2153        }
2154        else if (name.equals("code")) {
2155          this.code = new CodeableConcept();
2156          return this.code;
2157        }
2158        else if (name.equals("text")) {
2159          this.text = new Narrative();
2160          return this.text;
2161        }
2162        else if (name.equals("mode")) {
2163          throw new FHIRException("Cannot call addChild on a primitive type Composition.mode");
2164        }
2165        else if (name.equals("orderedBy")) {
2166          this.orderedBy = new CodeableConcept();
2167          return this.orderedBy;
2168        }
2169        else if (name.equals("entry")) {
2170          return addEntry();
2171        }
2172        else if (name.equals("emptyReason")) {
2173          this.emptyReason = new CodeableConcept();
2174          return this.emptyReason;
2175        }
2176        else if (name.equals("section")) {
2177          return addSection();
2178        }
2179        else
2180          return super.addChild(name);
2181      }
2182
2183      public SectionComponent copy() {
2184        SectionComponent dst = new SectionComponent();
2185        copyValues(dst);
2186        dst.title = title == null ? null : title.copy();
2187        dst.code = code == null ? null : code.copy();
2188        dst.text = text == null ? null : text.copy();
2189        dst.mode = mode == null ? null : mode.copy();
2190        dst.orderedBy = orderedBy == null ? null : orderedBy.copy();
2191        if (entry != null) {
2192          dst.entry = new ArrayList<Reference>();
2193          for (Reference i : entry)
2194            dst.entry.add(i.copy());
2195        };
2196        dst.emptyReason = emptyReason == null ? null : emptyReason.copy();
2197        if (section != null) {
2198          dst.section = new ArrayList<SectionComponent>();
2199          for (SectionComponent i : section)
2200            dst.section.add(i.copy());
2201        };
2202        return dst;
2203      }
2204
2205      @Override
2206      public boolean equalsDeep(Base other_) {
2207        if (!super.equalsDeep(other_))
2208          return false;
2209        if (!(other_ instanceof SectionComponent))
2210          return false;
2211        SectionComponent o = (SectionComponent) other_;
2212        return compareDeep(title, o.title, true) && compareDeep(code, o.code, true) && compareDeep(text, o.text, true)
2213           && compareDeep(mode, o.mode, true) && compareDeep(orderedBy, o.orderedBy, true) && compareDeep(entry, o.entry, true)
2214           && compareDeep(emptyReason, o.emptyReason, true) && compareDeep(section, o.section, true);
2215      }
2216
2217      @Override
2218      public boolean equalsShallow(Base other_) {
2219        if (!super.equalsShallow(other_))
2220          return false;
2221        if (!(other_ instanceof SectionComponent))
2222          return false;
2223        SectionComponent o = (SectionComponent) other_;
2224        return compareValues(title, o.title, true) && compareValues(mode, o.mode, true);
2225      }
2226
2227      public boolean isEmpty() {
2228        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(title, code, text, mode
2229          , orderedBy, entry, emptyReason, section);
2230      }
2231
2232  public String fhirType() {
2233    return "Composition.section";
2234
2235  }
2236
2237  }
2238
2239    /**
2240     * Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time.
2241     */
2242    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=1, modifier=false, summary=true)
2243    @Description(shortDefinition="Logical identifier of composition (version-independent)", formalDefinition="Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time." )
2244    protected Identifier identifier;
2245
2246    /**
2247     * The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.
2248     */
2249    @Child(name = "status", type = {CodeType.class}, order=1, min=1, max=1, modifier=true, summary=true)
2250    @Description(shortDefinition="preliminary | final | amended | entered-in-error", formalDefinition="The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document." )
2251    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/composition-status")
2252    protected Enumeration<CompositionStatus> status;
2253
2254    /**
2255     * Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition.
2256     */
2257    @Child(name = "type", type = {CodeableConcept.class}, order=2, min=1, max=1, modifier=false, summary=true)
2258    @Description(shortDefinition="Kind of composition (LOINC if possible)", formalDefinition="Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition." )
2259    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/doc-typecodes")
2260    protected CodeableConcept type;
2261
2262    /**
2263     * A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type.
2264     */
2265    @Child(name = "class", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=true)
2266    @Description(shortDefinition="Categorization of Composition", formalDefinition="A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type." )
2267    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/doc-classcodes")
2268    protected CodeableConcept class_;
2269
2270    /**
2271     * Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).
2272     */
2273    @Child(name = "subject", type = {Reference.class}, order=4, min=1, max=1, modifier=false, summary=true)
2274    @Description(shortDefinition="Who and/or what the composition is about", formalDefinition="Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure)." )
2275    protected Reference subject;
2276
2277    /**
2278     * The actual object that is the target of the reference (Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).)
2279     */
2280    protected Resource subjectTarget;
2281
2282    /**
2283     * Describes the clinical encounter or type of care this documentation is associated with.
2284     */
2285    @Child(name = "encounter", type = {Encounter.class}, order=5, min=0, max=1, modifier=false, summary=true)
2286    @Description(shortDefinition="Context of the Composition", formalDefinition="Describes the clinical encounter or type of care this documentation is associated with." )
2287    protected Reference encounter;
2288
2289    /**
2290     * The actual object that is the target of the reference (Describes the clinical encounter or type of care this documentation is associated with.)
2291     */
2292    protected Encounter encounterTarget;
2293
2294    /**
2295     * The composition editing time, when the composition was last logically changed by the author.
2296     */
2297    @Child(name = "date", type = {DateTimeType.class}, order=6, min=1, max=1, modifier=false, summary=true)
2298    @Description(shortDefinition="Composition editing time", formalDefinition="The composition editing time, when the composition was last logically changed by the author." )
2299    protected DateTimeType date;
2300
2301    /**
2302     * Identifies who is responsible for the information in the composition, not necessarily who typed it in.
2303     */
2304    @Child(name = "author", type = {Practitioner.class, Device.class, Patient.class, RelatedPerson.class}, order=7, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2305    @Description(shortDefinition="Who and/or what authored the composition", formalDefinition="Identifies who is responsible for the information in the composition, not necessarily who typed it in." )
2306    protected List<Reference> author;
2307    /**
2308     * The actual objects that are the target of the reference (Identifies who is responsible for the information in the composition, not necessarily who typed it in.)
2309     */
2310    protected List<Resource> authorTarget;
2311
2312
2313    /**
2314     * Official human-readable label for the composition.
2315     */
2316    @Child(name = "title", type = {StringType.class}, order=8, min=1, max=1, modifier=false, summary=true)
2317    @Description(shortDefinition="Human Readable name/title", formalDefinition="Official human-readable label for the composition." )
2318    protected StringType title;
2319
2320    /**
2321     * The code specifying the level of confidentiality of the Composition.
2322     */
2323    @Child(name = "confidentiality", type = {CodeType.class}, order=9, min=0, max=1, modifier=true, summary=true)
2324    @Description(shortDefinition="As defined by affinity domain", formalDefinition="The code specifying the level of confidentiality of the Composition." )
2325    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v3-ConfidentialityClassification")
2326    protected Enumeration<DocumentConfidentiality> confidentiality;
2327
2328    /**
2329     * A participant who has attested to the accuracy of the composition/document.
2330     */
2331    @Child(name = "attester", type = {}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2332    @Description(shortDefinition="Attests to accuracy of composition", formalDefinition="A participant who has attested to the accuracy of the composition/document." )
2333    protected List<CompositionAttesterComponent> attester;
2334
2335    /**
2336     * Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.
2337     */
2338    @Child(name = "custodian", type = {Organization.class}, order=11, min=0, max=1, modifier=false, summary=true)
2339    @Description(shortDefinition="Organization which maintains the composition", formalDefinition="Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information." )
2340    protected Reference custodian;
2341
2342    /**
2343     * The actual object that is the target of the reference (Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.)
2344     */
2345    protected Organization custodianTarget;
2346
2347    /**
2348     * Relationships that this composition has with other compositions or documents that already exist.
2349     */
2350    @Child(name = "relatesTo", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2351    @Description(shortDefinition="Relationships to other compositions/documents", formalDefinition="Relationships that this composition has with other compositions or documents that already exist." )
2352    protected List<CompositionRelatesToComponent> relatesTo;
2353
2354    /**
2355     * The clinical service, such as a colonoscopy or an appendectomy, being documented.
2356     */
2357    @Child(name = "event", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2358    @Description(shortDefinition="The clinical service(s) being documented", formalDefinition="The clinical service, such as a colonoscopy or an appendectomy, being documented." )
2359    protected List<CompositionEventComponent> event;
2360
2361    /**
2362     * The root of the sections that make up the composition.
2363     */
2364    @Child(name = "section", type = {}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2365    @Description(shortDefinition="Composition is broken into sections", formalDefinition="The root of the sections that make up the composition." )
2366    protected List<SectionComponent> section;
2367
2368    private static final long serialVersionUID = -1422555114L;
2369
2370  /**
2371   * Constructor
2372   */
2373    public Composition() {
2374      super();
2375    }
2376
2377  /**
2378   * Constructor
2379   */
2380    public Composition(Enumeration<CompositionStatus> status, CodeableConcept type, Reference subject, DateTimeType date, StringType title) {
2381      super();
2382      this.status = status;
2383      this.type = type;
2384      this.subject = subject;
2385      this.date = date;
2386      this.title = title;
2387    }
2388
2389    /**
2390     * @return {@link #identifier} (Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time.)
2391     */
2392    public Identifier getIdentifier() { 
2393      if (this.identifier == null)
2394        if (Configuration.errorOnAutoCreate())
2395          throw new Error("Attempt to auto-create Composition.identifier");
2396        else if (Configuration.doAutoCreate())
2397          this.identifier = new Identifier(); // cc
2398      return this.identifier;
2399    }
2400
2401    public boolean hasIdentifier() { 
2402      return this.identifier != null && !this.identifier.isEmpty();
2403    }
2404
2405    /**
2406     * @param value {@link #identifier} (Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time.)
2407     */
2408    public Composition setIdentifier(Identifier value)  { 
2409      this.identifier = value;
2410      return this;
2411    }
2412
2413    /**
2414     * @return {@link #status} (The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
2415     */
2416    public Enumeration<CompositionStatus> getStatusElement() { 
2417      if (this.status == null)
2418        if (Configuration.errorOnAutoCreate())
2419          throw new Error("Attempt to auto-create Composition.status");
2420        else if (Configuration.doAutoCreate())
2421          this.status = new Enumeration<CompositionStatus>(new CompositionStatusEnumFactory()); // bb
2422      return this.status;
2423    }
2424
2425    public boolean hasStatusElement() { 
2426      return this.status != null && !this.status.isEmpty();
2427    }
2428
2429    public boolean hasStatus() { 
2430      return this.status != null && !this.status.isEmpty();
2431    }
2432
2433    /**
2434     * @param value {@link #status} (The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
2435     */
2436    public Composition setStatusElement(Enumeration<CompositionStatus> value) { 
2437      this.status = value;
2438      return this;
2439    }
2440
2441    /**
2442     * @return The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.
2443     */
2444    public CompositionStatus getStatus() { 
2445      return this.status == null ? null : this.status.getValue();
2446    }
2447
2448    /**
2449     * @param value The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.
2450     */
2451    public Composition setStatus(CompositionStatus value) { 
2452        if (this.status == null)
2453          this.status = new Enumeration<CompositionStatus>(new CompositionStatusEnumFactory());
2454        this.status.setValue(value);
2455      return this;
2456    }
2457
2458    /**
2459     * @return {@link #type} (Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition.)
2460     */
2461    public CodeableConcept getType() { 
2462      if (this.type == null)
2463        if (Configuration.errorOnAutoCreate())
2464          throw new Error("Attempt to auto-create Composition.type");
2465        else if (Configuration.doAutoCreate())
2466          this.type = new CodeableConcept(); // cc
2467      return this.type;
2468    }
2469
2470    public boolean hasType() { 
2471      return this.type != null && !this.type.isEmpty();
2472    }
2473
2474    /**
2475     * @param value {@link #type} (Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition.)
2476     */
2477    public Composition setType(CodeableConcept value)  { 
2478      this.type = value;
2479      return this;
2480    }
2481
2482    /**
2483     * @return {@link #class_} (A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type.)
2484     */
2485    public CodeableConcept getClass_() { 
2486      if (this.class_ == null)
2487        if (Configuration.errorOnAutoCreate())
2488          throw new Error("Attempt to auto-create Composition.class_");
2489        else if (Configuration.doAutoCreate())
2490          this.class_ = new CodeableConcept(); // cc
2491      return this.class_;
2492    }
2493
2494    public boolean hasClass_() { 
2495      return this.class_ != null && !this.class_.isEmpty();
2496    }
2497
2498    /**
2499     * @param value {@link #class_} (A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type.)
2500     */
2501    public Composition setClass_(CodeableConcept value)  { 
2502      this.class_ = value;
2503      return this;
2504    }
2505
2506    /**
2507     * @return {@link #subject} (Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).)
2508     */
2509    public Reference getSubject() { 
2510      if (this.subject == null)
2511        if (Configuration.errorOnAutoCreate())
2512          throw new Error("Attempt to auto-create Composition.subject");
2513        else if (Configuration.doAutoCreate())
2514          this.subject = new Reference(); // cc
2515      return this.subject;
2516    }
2517
2518    public boolean hasSubject() { 
2519      return this.subject != null && !this.subject.isEmpty();
2520    }
2521
2522    /**
2523     * @param value {@link #subject} (Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).)
2524     */
2525    public Composition setSubject(Reference value)  { 
2526      this.subject = value;
2527      return this;
2528    }
2529
2530    /**
2531     * @return {@link #subject} 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. (Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).)
2532     */
2533    public Resource getSubjectTarget() { 
2534      return this.subjectTarget;
2535    }
2536
2537    /**
2538     * @param value {@link #subject} 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. (Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).)
2539     */
2540    public Composition setSubjectTarget(Resource value) { 
2541      this.subjectTarget = value;
2542      return this;
2543    }
2544
2545    /**
2546     * @return {@link #encounter} (Describes the clinical encounter or type of care this documentation is associated with.)
2547     */
2548    public Reference getEncounter() { 
2549      if (this.encounter == null)
2550        if (Configuration.errorOnAutoCreate())
2551          throw new Error("Attempt to auto-create Composition.encounter");
2552        else if (Configuration.doAutoCreate())
2553          this.encounter = new Reference(); // cc
2554      return this.encounter;
2555    }
2556
2557    public boolean hasEncounter() { 
2558      return this.encounter != null && !this.encounter.isEmpty();
2559    }
2560
2561    /**
2562     * @param value {@link #encounter} (Describes the clinical encounter or type of care this documentation is associated with.)
2563     */
2564    public Composition setEncounter(Reference value)  { 
2565      this.encounter = value;
2566      return this;
2567    }
2568
2569    /**
2570     * @return {@link #encounter} 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. (Describes the clinical encounter or type of care this documentation is associated with.)
2571     */
2572    public Encounter getEncounterTarget() { 
2573      if (this.encounterTarget == null)
2574        if (Configuration.errorOnAutoCreate())
2575          throw new Error("Attempt to auto-create Composition.encounter");
2576        else if (Configuration.doAutoCreate())
2577          this.encounterTarget = new Encounter(); // aa
2578      return this.encounterTarget;
2579    }
2580
2581    /**
2582     * @param value {@link #encounter} 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. (Describes the clinical encounter or type of care this documentation is associated with.)
2583     */
2584    public Composition setEncounterTarget(Encounter value) { 
2585      this.encounterTarget = value;
2586      return this;
2587    }
2588
2589    /**
2590     * @return {@link #date} (The composition editing time, when the composition was last logically changed by the author.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
2591     */
2592    public DateTimeType getDateElement() { 
2593      if (this.date == null)
2594        if (Configuration.errorOnAutoCreate())
2595          throw new Error("Attempt to auto-create Composition.date");
2596        else if (Configuration.doAutoCreate())
2597          this.date = new DateTimeType(); // bb
2598      return this.date;
2599    }
2600
2601    public boolean hasDateElement() { 
2602      return this.date != null && !this.date.isEmpty();
2603    }
2604
2605    public boolean hasDate() { 
2606      return this.date != null && !this.date.isEmpty();
2607    }
2608
2609    /**
2610     * @param value {@link #date} (The composition editing time, when the composition was last logically changed by the author.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
2611     */
2612    public Composition setDateElement(DateTimeType value) { 
2613      this.date = value;
2614      return this;
2615    }
2616
2617    /**
2618     * @return The composition editing time, when the composition was last logically changed by the author.
2619     */
2620    public Date getDate() { 
2621      return this.date == null ? null : this.date.getValue();
2622    }
2623
2624    /**
2625     * @param value The composition editing time, when the composition was last logically changed by the author.
2626     */
2627    public Composition setDate(Date value) { 
2628        if (this.date == null)
2629          this.date = new DateTimeType();
2630        this.date.setValue(value);
2631      return this;
2632    }
2633
2634    /**
2635     * @return {@link #author} (Identifies who is responsible for the information in the composition, not necessarily who typed it in.)
2636     */
2637    public List<Reference> getAuthor() { 
2638      if (this.author == null)
2639        this.author = new ArrayList<Reference>();
2640      return this.author;
2641    }
2642
2643    /**
2644     * @return Returns a reference to <code>this</code> for easy method chaining
2645     */
2646    public Composition setAuthor(List<Reference> theAuthor) { 
2647      this.author = theAuthor;
2648      return this;
2649    }
2650
2651    public boolean hasAuthor() { 
2652      if (this.author == null)
2653        return false;
2654      for (Reference item : this.author)
2655        if (!item.isEmpty())
2656          return true;
2657      return false;
2658    }
2659
2660    public Reference addAuthor() { //3
2661      Reference t = new Reference();
2662      if (this.author == null)
2663        this.author = new ArrayList<Reference>();
2664      this.author.add(t);
2665      return t;
2666    }
2667
2668    public Composition addAuthor(Reference t) { //3
2669      if (t == null)
2670        return this;
2671      if (this.author == null)
2672        this.author = new ArrayList<Reference>();
2673      this.author.add(t);
2674      return this;
2675    }
2676
2677    /**
2678     * @return The first repetition of repeating field {@link #author}, creating it if it does not already exist
2679     */
2680    public Reference getAuthorFirstRep() { 
2681      if (getAuthor().isEmpty()) {
2682        addAuthor();
2683      }
2684      return getAuthor().get(0);
2685    }
2686
2687    /**
2688     * @deprecated Use Reference#setResource(IBaseResource) instead
2689     */
2690    @Deprecated
2691    public List<Resource> getAuthorTarget() { 
2692      if (this.authorTarget == null)
2693        this.authorTarget = new ArrayList<Resource>();
2694      return this.authorTarget;
2695    }
2696
2697    /**
2698     * @return {@link #title} (Official human-readable label for the composition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
2699     */
2700    public StringType getTitleElement() { 
2701      if (this.title == null)
2702        if (Configuration.errorOnAutoCreate())
2703          throw new Error("Attempt to auto-create Composition.title");
2704        else if (Configuration.doAutoCreate())
2705          this.title = new StringType(); // bb
2706      return this.title;
2707    }
2708
2709    public boolean hasTitleElement() { 
2710      return this.title != null && !this.title.isEmpty();
2711    }
2712
2713    public boolean hasTitle() { 
2714      return this.title != null && !this.title.isEmpty();
2715    }
2716
2717    /**
2718     * @param value {@link #title} (Official human-readable label for the composition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
2719     */
2720    public Composition setTitleElement(StringType value) { 
2721      this.title = value;
2722      return this;
2723    }
2724
2725    /**
2726     * @return Official human-readable label for the composition.
2727     */
2728    public String getTitle() { 
2729      return this.title == null ? null : this.title.getValue();
2730    }
2731
2732    /**
2733     * @param value Official human-readable label for the composition.
2734     */
2735    public Composition setTitle(String value) { 
2736        if (this.title == null)
2737          this.title = new StringType();
2738        this.title.setValue(value);
2739      return this;
2740    }
2741
2742    /**
2743     * @return {@link #confidentiality} (The code specifying the level of confidentiality of the Composition.). This is the underlying object with id, value and extensions. The accessor "getConfidentiality" gives direct access to the value
2744     */
2745    public Enumeration<DocumentConfidentiality> getConfidentialityElement() { 
2746      if (this.confidentiality == null)
2747        if (Configuration.errorOnAutoCreate())
2748          throw new Error("Attempt to auto-create Composition.confidentiality");
2749        else if (Configuration.doAutoCreate())
2750          this.confidentiality = new Enumeration<DocumentConfidentiality>(new DocumentConfidentialityEnumFactory()); // bb
2751      return this.confidentiality;
2752    }
2753
2754    public boolean hasConfidentialityElement() { 
2755      return this.confidentiality != null && !this.confidentiality.isEmpty();
2756    }
2757
2758    public boolean hasConfidentiality() { 
2759      return this.confidentiality != null && !this.confidentiality.isEmpty();
2760    }
2761
2762    /**
2763     * @param value {@link #confidentiality} (The code specifying the level of confidentiality of the Composition.). This is the underlying object with id, value and extensions. The accessor "getConfidentiality" gives direct access to the value
2764     */
2765    public Composition setConfidentialityElement(Enumeration<DocumentConfidentiality> value) { 
2766      this.confidentiality = value;
2767      return this;
2768    }
2769
2770    /**
2771     * @return The code specifying the level of confidentiality of the Composition.
2772     */
2773    public DocumentConfidentiality getConfidentiality() { 
2774      return this.confidentiality == null ? null : this.confidentiality.getValue();
2775    }
2776
2777    /**
2778     * @param value The code specifying the level of confidentiality of the Composition.
2779     */
2780    public Composition setConfidentiality(DocumentConfidentiality value) { 
2781      if (value == null)
2782        this.confidentiality = null;
2783      else {
2784        if (this.confidentiality == null)
2785          this.confidentiality = new Enumeration<DocumentConfidentiality>(new DocumentConfidentialityEnumFactory());
2786        this.confidentiality.setValue(value);
2787      }
2788      return this;
2789    }
2790
2791    /**
2792     * @return {@link #attester} (A participant who has attested to the accuracy of the composition/document.)
2793     */
2794    public List<CompositionAttesterComponent> getAttester() { 
2795      if (this.attester == null)
2796        this.attester = new ArrayList<CompositionAttesterComponent>();
2797      return this.attester;
2798    }
2799
2800    /**
2801     * @return Returns a reference to <code>this</code> for easy method chaining
2802     */
2803    public Composition setAttester(List<CompositionAttesterComponent> theAttester) { 
2804      this.attester = theAttester;
2805      return this;
2806    }
2807
2808    public boolean hasAttester() { 
2809      if (this.attester == null)
2810        return false;
2811      for (CompositionAttesterComponent item : this.attester)
2812        if (!item.isEmpty())
2813          return true;
2814      return false;
2815    }
2816
2817    public CompositionAttesterComponent addAttester() { //3
2818      CompositionAttesterComponent t = new CompositionAttesterComponent();
2819      if (this.attester == null)
2820        this.attester = new ArrayList<CompositionAttesterComponent>();
2821      this.attester.add(t);
2822      return t;
2823    }
2824
2825    public Composition addAttester(CompositionAttesterComponent t) { //3
2826      if (t == null)
2827        return this;
2828      if (this.attester == null)
2829        this.attester = new ArrayList<CompositionAttesterComponent>();
2830      this.attester.add(t);
2831      return this;
2832    }
2833
2834    /**
2835     * @return The first repetition of repeating field {@link #attester}, creating it if it does not already exist
2836     */
2837    public CompositionAttesterComponent getAttesterFirstRep() { 
2838      if (getAttester().isEmpty()) {
2839        addAttester();
2840      }
2841      return getAttester().get(0);
2842    }
2843
2844    /**
2845     * @return {@link #custodian} (Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.)
2846     */
2847    public Reference getCustodian() { 
2848      if (this.custodian == null)
2849        if (Configuration.errorOnAutoCreate())
2850          throw new Error("Attempt to auto-create Composition.custodian");
2851        else if (Configuration.doAutoCreate())
2852          this.custodian = new Reference(); // cc
2853      return this.custodian;
2854    }
2855
2856    public boolean hasCustodian() { 
2857      return this.custodian != null && !this.custodian.isEmpty();
2858    }
2859
2860    /**
2861     * @param value {@link #custodian} (Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.)
2862     */
2863    public Composition setCustodian(Reference value)  { 
2864      this.custodian = value;
2865      return this;
2866    }
2867
2868    /**
2869     * @return {@link #custodian} 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. (Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.)
2870     */
2871    public Organization getCustodianTarget() { 
2872      if (this.custodianTarget == null)
2873        if (Configuration.errorOnAutoCreate())
2874          throw new Error("Attempt to auto-create Composition.custodian");
2875        else if (Configuration.doAutoCreate())
2876          this.custodianTarget = new Organization(); // aa
2877      return this.custodianTarget;
2878    }
2879
2880    /**
2881     * @param value {@link #custodian} 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. (Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.)
2882     */
2883    public Composition setCustodianTarget(Organization value) { 
2884      this.custodianTarget = value;
2885      return this;
2886    }
2887
2888    /**
2889     * @return {@link #relatesTo} (Relationships that this composition has with other compositions or documents that already exist.)
2890     */
2891    public List<CompositionRelatesToComponent> getRelatesTo() { 
2892      if (this.relatesTo == null)
2893        this.relatesTo = new ArrayList<CompositionRelatesToComponent>();
2894      return this.relatesTo;
2895    }
2896
2897    /**
2898     * @return Returns a reference to <code>this</code> for easy method chaining
2899     */
2900    public Composition setRelatesTo(List<CompositionRelatesToComponent> theRelatesTo) { 
2901      this.relatesTo = theRelatesTo;
2902      return this;
2903    }
2904
2905    public boolean hasRelatesTo() { 
2906      if (this.relatesTo == null)
2907        return false;
2908      for (CompositionRelatesToComponent item : this.relatesTo)
2909        if (!item.isEmpty())
2910          return true;
2911      return false;
2912    }
2913
2914    public CompositionRelatesToComponent addRelatesTo() { //3
2915      CompositionRelatesToComponent t = new CompositionRelatesToComponent();
2916      if (this.relatesTo == null)
2917        this.relatesTo = new ArrayList<CompositionRelatesToComponent>();
2918      this.relatesTo.add(t);
2919      return t;
2920    }
2921
2922    public Composition addRelatesTo(CompositionRelatesToComponent t) { //3
2923      if (t == null)
2924        return this;
2925      if (this.relatesTo == null)
2926        this.relatesTo = new ArrayList<CompositionRelatesToComponent>();
2927      this.relatesTo.add(t);
2928      return this;
2929    }
2930
2931    /**
2932     * @return The first repetition of repeating field {@link #relatesTo}, creating it if it does not already exist
2933     */
2934    public CompositionRelatesToComponent getRelatesToFirstRep() { 
2935      if (getRelatesTo().isEmpty()) {
2936        addRelatesTo();
2937      }
2938      return getRelatesTo().get(0);
2939    }
2940
2941    /**
2942     * @return {@link #event} (The clinical service, such as a colonoscopy or an appendectomy, being documented.)
2943     */
2944    public List<CompositionEventComponent> getEvent() { 
2945      if (this.event == null)
2946        this.event = new ArrayList<CompositionEventComponent>();
2947      return this.event;
2948    }
2949
2950    /**
2951     * @return Returns a reference to <code>this</code> for easy method chaining
2952     */
2953    public Composition setEvent(List<CompositionEventComponent> theEvent) { 
2954      this.event = theEvent;
2955      return this;
2956    }
2957
2958    public boolean hasEvent() { 
2959      if (this.event == null)
2960        return false;
2961      for (CompositionEventComponent item : this.event)
2962        if (!item.isEmpty())
2963          return true;
2964      return false;
2965    }
2966
2967    public CompositionEventComponent addEvent() { //3
2968      CompositionEventComponent t = new CompositionEventComponent();
2969      if (this.event == null)
2970        this.event = new ArrayList<CompositionEventComponent>();
2971      this.event.add(t);
2972      return t;
2973    }
2974
2975    public Composition addEvent(CompositionEventComponent t) { //3
2976      if (t == null)
2977        return this;
2978      if (this.event == null)
2979        this.event = new ArrayList<CompositionEventComponent>();
2980      this.event.add(t);
2981      return this;
2982    }
2983
2984    /**
2985     * @return The first repetition of repeating field {@link #event}, creating it if it does not already exist
2986     */
2987    public CompositionEventComponent getEventFirstRep() { 
2988      if (getEvent().isEmpty()) {
2989        addEvent();
2990      }
2991      return getEvent().get(0);
2992    }
2993
2994    /**
2995     * @return {@link #section} (The root of the sections that make up the composition.)
2996     */
2997    public List<SectionComponent> getSection() { 
2998      if (this.section == null)
2999        this.section = new ArrayList<SectionComponent>();
3000      return this.section;
3001    }
3002
3003    /**
3004     * @return Returns a reference to <code>this</code> for easy method chaining
3005     */
3006    public Composition setSection(List<SectionComponent> theSection) { 
3007      this.section = theSection;
3008      return this;
3009    }
3010
3011    public boolean hasSection() { 
3012      if (this.section == null)
3013        return false;
3014      for (SectionComponent item : this.section)
3015        if (!item.isEmpty())
3016          return true;
3017      return false;
3018    }
3019
3020    public SectionComponent addSection() { //3
3021      SectionComponent t = new SectionComponent();
3022      if (this.section == null)
3023        this.section = new ArrayList<SectionComponent>();
3024      this.section.add(t);
3025      return t;
3026    }
3027
3028    public Composition addSection(SectionComponent t) { //3
3029      if (t == null)
3030        return this;
3031      if (this.section == null)
3032        this.section = new ArrayList<SectionComponent>();
3033      this.section.add(t);
3034      return this;
3035    }
3036
3037    /**
3038     * @return The first repetition of repeating field {@link #section}, creating it if it does not already exist
3039     */
3040    public SectionComponent getSectionFirstRep() { 
3041      if (getSection().isEmpty()) {
3042        addSection();
3043      }
3044      return getSection().get(0);
3045    }
3046
3047      protected void listChildren(List<Property> children) {
3048        super.listChildren(children);
3049        children.add(new Property("identifier", "Identifier", "Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time.", 0, 1, identifier));
3050        children.add(new Property("status", "code", "The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.", 0, 1, status));
3051        children.add(new Property("type", "CodeableConcept", "Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition.", 0, 1, type));
3052        children.add(new Property("class", "CodeableConcept", "A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type.", 0, 1, class_));
3053        children.add(new Property("subject", "Reference(Any)", "Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).", 0, 1, subject));
3054        children.add(new Property("encounter", "Reference(Encounter)", "Describes the clinical encounter or type of care this documentation is associated with.", 0, 1, encounter));
3055        children.add(new Property("date", "dateTime", "The composition editing time, when the composition was last logically changed by the author.", 0, 1, date));
3056        children.add(new Property("author", "Reference(Practitioner|Device|Patient|RelatedPerson)", "Identifies who is responsible for the information in the composition, not necessarily who typed it in.", 0, java.lang.Integer.MAX_VALUE, author));
3057        children.add(new Property("title", "string", "Official human-readable label for the composition.", 0, 1, title));
3058        children.add(new Property("confidentiality", "code", "The code specifying the level of confidentiality of the Composition.", 0, 1, confidentiality));
3059        children.add(new Property("attester", "", "A participant who has attested to the accuracy of the composition/document.", 0, java.lang.Integer.MAX_VALUE, attester));
3060        children.add(new Property("custodian", "Reference(Organization)", "Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.", 0, 1, custodian));
3061        children.add(new Property("relatesTo", "", "Relationships that this composition has with other compositions or documents that already exist.", 0, java.lang.Integer.MAX_VALUE, relatesTo));
3062        children.add(new Property("event", "", "The clinical service, such as a colonoscopy or an appendectomy, being documented.", 0, java.lang.Integer.MAX_VALUE, event));
3063        children.add(new Property("section", "", "The root of the sections that make up the composition.", 0, java.lang.Integer.MAX_VALUE, section));
3064      }
3065
3066      @Override
3067      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3068        switch (_hash) {
3069        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Logical identifier for the composition, assigned when created. This identifier stays constant as the composition is changed over time.", 0, 1, identifier);
3070        case -892481550: /*status*/  return new Property("status", "code", "The workflow/clinical status of this composition. The status is a marker for the clinical standing of the document.", 0, 1, status);
3071        case 3575610: /*type*/  return new Property("type", "CodeableConcept", "Specifies the particular kind of composition (e.g. History and Physical, Discharge Summary, Progress Note). This usually equates to the purpose of making the composition.", 0, 1, type);
3072        case 94742904: /*class*/  return new Property("class", "CodeableConcept", "A categorization for the type of the composition - helps for indexing and searching. This may be implied by or derived from the code specified in the Composition Type.", 0, 1, class_);
3073        case -1867885268: /*subject*/  return new Property("subject", "Reference(Any)", "Who or what the composition is about. The composition can be about a person, (patient or healthcare practitioner), a device (e.g. a machine) or even a group of subjects (such as a document about a herd of livestock, or a set of patients that share a common exposure).", 0, 1, subject);
3074        case 1524132147: /*encounter*/  return new Property("encounter", "Reference(Encounter)", "Describes the clinical encounter or type of care this documentation is associated with.", 0, 1, encounter);
3075        case 3076014: /*date*/  return new Property("date", "dateTime", "The composition editing time, when the composition was last logically changed by the author.", 0, 1, date);
3076        case -1406328437: /*author*/  return new Property("author", "Reference(Practitioner|Device|Patient|RelatedPerson)", "Identifies who is responsible for the information in the composition, not necessarily who typed it in.", 0, java.lang.Integer.MAX_VALUE, author);
3077        case 110371416: /*title*/  return new Property("title", "string", "Official human-readable label for the composition.", 0, 1, title);
3078        case -1923018202: /*confidentiality*/  return new Property("confidentiality", "code", "The code specifying the level of confidentiality of the Composition.", 0, 1, confidentiality);
3079        case 542920370: /*attester*/  return new Property("attester", "", "A participant who has attested to the accuracy of the composition/document.", 0, java.lang.Integer.MAX_VALUE, attester);
3080        case 1611297262: /*custodian*/  return new Property("custodian", "Reference(Organization)", "Identifies the organization or group who is responsible for ongoing maintenance of and access to the composition/document information.", 0, 1, custodian);
3081        case -7765931: /*relatesTo*/  return new Property("relatesTo", "", "Relationships that this composition has with other compositions or documents that already exist.", 0, java.lang.Integer.MAX_VALUE, relatesTo);
3082        case 96891546: /*event*/  return new Property("event", "", "The clinical service, such as a colonoscopy or an appendectomy, being documented.", 0, java.lang.Integer.MAX_VALUE, event);
3083        case 1970241253: /*section*/  return new Property("section", "", "The root of the sections that make up the composition.", 0, java.lang.Integer.MAX_VALUE, section);
3084        default: return super.getNamedProperty(_hash, _name, _checkValid);
3085        }
3086
3087      }
3088
3089      @Override
3090      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3091        switch (hash) {
3092        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : new Base[] {this.identifier}; // Identifier
3093        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<CompositionStatus>
3094        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
3095        case 94742904: /*class*/ return this.class_ == null ? new Base[0] : new Base[] {this.class_}; // CodeableConcept
3096        case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference
3097        case 1524132147: /*encounter*/ return this.encounter == null ? new Base[0] : new Base[] {this.encounter}; // Reference
3098        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
3099        case -1406328437: /*author*/ return this.author == null ? new Base[0] : this.author.toArray(new Base[this.author.size()]); // Reference
3100        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
3101        case -1923018202: /*confidentiality*/ return this.confidentiality == null ? new Base[0] : new Base[] {this.confidentiality}; // Enumeration<DocumentConfidentiality>
3102        case 542920370: /*attester*/ return this.attester == null ? new Base[0] : this.attester.toArray(new Base[this.attester.size()]); // CompositionAttesterComponent
3103        case 1611297262: /*custodian*/ return this.custodian == null ? new Base[0] : new Base[] {this.custodian}; // Reference
3104        case -7765931: /*relatesTo*/ return this.relatesTo == null ? new Base[0] : this.relatesTo.toArray(new Base[this.relatesTo.size()]); // CompositionRelatesToComponent
3105        case 96891546: /*event*/ return this.event == null ? new Base[0] : this.event.toArray(new Base[this.event.size()]); // CompositionEventComponent
3106        case 1970241253: /*section*/ return this.section == null ? new Base[0] : this.section.toArray(new Base[this.section.size()]); // SectionComponent
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 -1618432855: // identifier
3116          this.identifier = castToIdentifier(value); // Identifier
3117          return value;
3118        case -892481550: // status
3119          value = new CompositionStatusEnumFactory().fromType(castToCode(value));
3120          this.status = (Enumeration) value; // Enumeration<CompositionStatus>
3121          return value;
3122        case 3575610: // type
3123          this.type = castToCodeableConcept(value); // CodeableConcept
3124          return value;
3125        case 94742904: // class
3126          this.class_ = castToCodeableConcept(value); // CodeableConcept
3127          return value;
3128        case -1867885268: // subject
3129          this.subject = castToReference(value); // Reference
3130          return value;
3131        case 1524132147: // encounter
3132          this.encounter = castToReference(value); // Reference
3133          return value;
3134        case 3076014: // date
3135          this.date = castToDateTime(value); // DateTimeType
3136          return value;
3137        case -1406328437: // author
3138          this.getAuthor().add(castToReference(value)); // Reference
3139          return value;
3140        case 110371416: // title
3141          this.title = castToString(value); // StringType
3142          return value;
3143        case -1923018202: // confidentiality
3144          value = new DocumentConfidentialityEnumFactory().fromType(castToCode(value));
3145          this.confidentiality = (Enumeration) value; // Enumeration<DocumentConfidentiality>
3146          return value;
3147        case 542920370: // attester
3148          this.getAttester().add((CompositionAttesterComponent) value); // CompositionAttesterComponent
3149          return value;
3150        case 1611297262: // custodian
3151          this.custodian = castToReference(value); // Reference
3152          return value;
3153        case -7765931: // relatesTo
3154          this.getRelatesTo().add((CompositionRelatesToComponent) value); // CompositionRelatesToComponent
3155          return value;
3156        case 96891546: // event
3157          this.getEvent().add((CompositionEventComponent) value); // CompositionEventComponent
3158          return value;
3159        case 1970241253: // section
3160          this.getSection().add((SectionComponent) value); // SectionComponent
3161          return value;
3162        default: return super.setProperty(hash, name, value);
3163        }
3164
3165      }
3166
3167      @Override
3168      public Base setProperty(String name, Base value) throws FHIRException {
3169        if (name.equals("identifier")) {
3170          this.identifier = castToIdentifier(value); // Identifier
3171        } else if (name.equals("status")) {
3172          value = new CompositionStatusEnumFactory().fromType(castToCode(value));
3173          this.status = (Enumeration) value; // Enumeration<CompositionStatus>
3174        } else if (name.equals("type")) {
3175          this.type = castToCodeableConcept(value); // CodeableConcept
3176        } else if (name.equals("class")) {
3177          this.class_ = castToCodeableConcept(value); // CodeableConcept
3178        } else if (name.equals("subject")) {
3179          this.subject = castToReference(value); // Reference
3180        } else if (name.equals("encounter")) {
3181          this.encounter = castToReference(value); // Reference
3182        } else if (name.equals("date")) {
3183          this.date = castToDateTime(value); // DateTimeType
3184        } else if (name.equals("author")) {
3185          this.getAuthor().add(castToReference(value));
3186        } else if (name.equals("title")) {
3187          this.title = castToString(value); // StringType
3188        } else if (name.equals("confidentiality")) {
3189          value = new DocumentConfidentialityEnumFactory().fromType(castToCode(value));
3190          this.confidentiality = (Enumeration) value; // Enumeration<DocumentConfidentiality>
3191        } else if (name.equals("attester")) {
3192          this.getAttester().add((CompositionAttesterComponent) value);
3193        } else if (name.equals("custodian")) {
3194          this.custodian = castToReference(value); // Reference
3195        } else if (name.equals("relatesTo")) {
3196          this.getRelatesTo().add((CompositionRelatesToComponent) value);
3197        } else if (name.equals("event")) {
3198          this.getEvent().add((CompositionEventComponent) value);
3199        } else if (name.equals("section")) {
3200          this.getSection().add((SectionComponent) value);
3201        } else
3202          return super.setProperty(name, value);
3203        return value;
3204      }
3205
3206      @Override
3207      public Base makeProperty(int hash, String name) throws FHIRException {
3208        switch (hash) {
3209        case -1618432855:  return getIdentifier(); 
3210        case -892481550:  return getStatusElement();
3211        case 3575610:  return getType(); 
3212        case 94742904:  return getClass_(); 
3213        case -1867885268:  return getSubject(); 
3214        case 1524132147:  return getEncounter(); 
3215        case 3076014:  return getDateElement();
3216        case -1406328437:  return addAuthor(); 
3217        case 110371416:  return getTitleElement();
3218        case -1923018202:  return getConfidentialityElement();
3219        case 542920370:  return addAttester(); 
3220        case 1611297262:  return getCustodian(); 
3221        case -7765931:  return addRelatesTo(); 
3222        case 96891546:  return addEvent(); 
3223        case 1970241253:  return addSection(); 
3224        default: return super.makeProperty(hash, name);
3225        }
3226
3227      }
3228
3229      @Override
3230      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3231        switch (hash) {
3232        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
3233        case -892481550: /*status*/ return new String[] {"code"};
3234        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
3235        case 94742904: /*class*/ return new String[] {"CodeableConcept"};
3236        case -1867885268: /*subject*/ return new String[] {"Reference"};
3237        case 1524132147: /*encounter*/ return new String[] {"Reference"};
3238        case 3076014: /*date*/ return new String[] {"dateTime"};
3239        case -1406328437: /*author*/ return new String[] {"Reference"};
3240        case 110371416: /*title*/ return new String[] {"string"};
3241        case -1923018202: /*confidentiality*/ return new String[] {"code"};
3242        case 542920370: /*attester*/ return new String[] {};
3243        case 1611297262: /*custodian*/ return new String[] {"Reference"};
3244        case -7765931: /*relatesTo*/ return new String[] {};
3245        case 96891546: /*event*/ return new String[] {};
3246        case 1970241253: /*section*/ return new String[] {};
3247        default: return super.getTypesForProperty(hash, name);
3248        }
3249
3250      }
3251
3252      @Override
3253      public Base addChild(String name) throws FHIRException {
3254        if (name.equals("identifier")) {
3255          this.identifier = new Identifier();
3256          return this.identifier;
3257        }
3258        else if (name.equals("status")) {
3259          throw new FHIRException("Cannot call addChild on a primitive type Composition.status");
3260        }
3261        else if (name.equals("type")) {
3262          this.type = new CodeableConcept();
3263          return this.type;
3264        }
3265        else if (name.equals("class")) {
3266          this.class_ = new CodeableConcept();
3267          return this.class_;
3268        }
3269        else if (name.equals("subject")) {
3270          this.subject = new Reference();
3271          return this.subject;
3272        }
3273        else if (name.equals("encounter")) {
3274          this.encounter = new Reference();
3275          return this.encounter;
3276        }
3277        else if (name.equals("date")) {
3278          throw new FHIRException("Cannot call addChild on a primitive type Composition.date");
3279        }
3280        else if (name.equals("author")) {
3281          return addAuthor();
3282        }
3283        else if (name.equals("title")) {
3284          throw new FHIRException("Cannot call addChild on a primitive type Composition.title");
3285        }
3286        else if (name.equals("confidentiality")) {
3287          throw new FHIRException("Cannot call addChild on a primitive type Composition.confidentiality");
3288        }
3289        else if (name.equals("attester")) {
3290          return addAttester();
3291        }
3292        else if (name.equals("custodian")) {
3293          this.custodian = new Reference();
3294          return this.custodian;
3295        }
3296        else if (name.equals("relatesTo")) {
3297          return addRelatesTo();
3298        }
3299        else if (name.equals("event")) {
3300          return addEvent();
3301        }
3302        else if (name.equals("section")) {
3303          return addSection();
3304        }
3305        else
3306          return super.addChild(name);
3307      }
3308
3309  public String fhirType() {
3310    return "Composition";
3311
3312  }
3313
3314      public Composition copy() {
3315        Composition dst = new Composition();
3316        copyValues(dst);
3317        dst.identifier = identifier == null ? null : identifier.copy();
3318        dst.status = status == null ? null : status.copy();
3319        dst.type = type == null ? null : type.copy();
3320        dst.class_ = class_ == null ? null : class_.copy();
3321        dst.subject = subject == null ? null : subject.copy();
3322        dst.encounter = encounter == null ? null : encounter.copy();
3323        dst.date = date == null ? null : date.copy();
3324        if (author != null) {
3325          dst.author = new ArrayList<Reference>();
3326          for (Reference i : author)
3327            dst.author.add(i.copy());
3328        };
3329        dst.title = title == null ? null : title.copy();
3330        dst.confidentiality = confidentiality == null ? null : confidentiality.copy();
3331        if (attester != null) {
3332          dst.attester = new ArrayList<CompositionAttesterComponent>();
3333          for (CompositionAttesterComponent i : attester)
3334            dst.attester.add(i.copy());
3335        };
3336        dst.custodian = custodian == null ? null : custodian.copy();
3337        if (relatesTo != null) {
3338          dst.relatesTo = new ArrayList<CompositionRelatesToComponent>();
3339          for (CompositionRelatesToComponent i : relatesTo)
3340            dst.relatesTo.add(i.copy());
3341        };
3342        if (event != null) {
3343          dst.event = new ArrayList<CompositionEventComponent>();
3344          for (CompositionEventComponent i : event)
3345            dst.event.add(i.copy());
3346        };
3347        if (section != null) {
3348          dst.section = new ArrayList<SectionComponent>();
3349          for (SectionComponent i : section)
3350            dst.section.add(i.copy());
3351        };
3352        return dst;
3353      }
3354
3355      protected Composition typedCopy() {
3356        return copy();
3357      }
3358
3359      @Override
3360      public boolean equalsDeep(Base other_) {
3361        if (!super.equalsDeep(other_))
3362          return false;
3363        if (!(other_ instanceof Composition))
3364          return false;
3365        Composition o = (Composition) other_;
3366        return compareDeep(identifier, o.identifier, true) && compareDeep(status, o.status, true) && compareDeep(type, o.type, true)
3367           && compareDeep(class_, o.class_, true) && compareDeep(subject, o.subject, true) && compareDeep(encounter, o.encounter, true)
3368           && compareDeep(date, o.date, true) && compareDeep(author, o.author, true) && compareDeep(title, o.title, true)
3369           && compareDeep(confidentiality, o.confidentiality, true) && compareDeep(attester, o.attester, true)
3370           && compareDeep(custodian, o.custodian, true) && compareDeep(relatesTo, o.relatesTo, true) && compareDeep(event, o.event, true)
3371           && compareDeep(section, o.section, true);
3372      }
3373
3374      @Override
3375      public boolean equalsShallow(Base other_) {
3376        if (!super.equalsShallow(other_))
3377          return false;
3378        if (!(other_ instanceof Composition))
3379          return false;
3380        Composition o = (Composition) other_;
3381        return compareValues(status, o.status, true) && compareValues(date, o.date, true) && compareValues(title, o.title, true)
3382           && compareValues(confidentiality, o.confidentiality, true);
3383      }
3384
3385      public boolean isEmpty() {
3386        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, status, type
3387          , class_, subject, encounter, date, author, title, confidentiality, attester
3388          , custodian, relatesTo, event, section);
3389      }
3390
3391  @Override
3392  public ResourceType getResourceType() {
3393    return ResourceType.Composition;
3394   }
3395
3396 /**
3397   * Search parameter: <b>date</b>
3398   * <p>
3399   * Description: <b>Composition editing time</b><br>
3400   * Type: <b>date</b><br>
3401   * Path: <b>Composition.date</b><br>
3402   * </p>
3403   */
3404  @SearchParamDefinition(name="date", path="Composition.date", description="Composition editing time", type="date" )
3405  public static final String SP_DATE = "date";
3406 /**
3407   * <b>Fluent Client</b> search parameter constant for <b>date</b>
3408   * <p>
3409   * Description: <b>Composition editing time</b><br>
3410   * Type: <b>date</b><br>
3411   * Path: <b>Composition.date</b><br>
3412   * </p>
3413   */
3414  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
3415
3416 /**
3417   * Search parameter: <b>identifier</b>
3418   * <p>
3419   * Description: <b>Logical identifier of composition (version-independent)</b><br>
3420   * Type: <b>token</b><br>
3421   * Path: <b>Composition.identifier</b><br>
3422   * </p>
3423   */
3424  @SearchParamDefinition(name="identifier", path="Composition.identifier", description="Logical identifier of composition (version-independent)", type="token" )
3425  public static final String SP_IDENTIFIER = "identifier";
3426 /**
3427   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
3428   * <p>
3429   * Description: <b>Logical identifier of composition (version-independent)</b><br>
3430   * Type: <b>token</b><br>
3431   * Path: <b>Composition.identifier</b><br>
3432   * </p>
3433   */
3434  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
3435
3436 /**
3437   * Search parameter: <b>period</b>
3438   * <p>
3439   * Description: <b>The period covered by the documentation</b><br>
3440   * Type: <b>date</b><br>
3441   * Path: <b>Composition.event.period</b><br>
3442   * </p>
3443   */
3444  @SearchParamDefinition(name="period", path="Composition.event.period", description="The period covered by the documentation", type="date" )
3445  public static final String SP_PERIOD = "period";
3446 /**
3447   * <b>Fluent Client</b> search parameter constant for <b>period</b>
3448   * <p>
3449   * Description: <b>The period covered by the documentation</b><br>
3450   * Type: <b>date</b><br>
3451   * Path: <b>Composition.event.period</b><br>
3452   * </p>
3453   */
3454  public static final ca.uhn.fhir.rest.gclient.DateClientParam PERIOD = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_PERIOD);
3455
3456 /**
3457   * Search parameter: <b>related-id</b>
3458   * <p>
3459   * Description: <b>Target of the relationship</b><br>
3460   * Type: <b>token</b><br>
3461   * Path: <b>Composition.relatesTo.targetIdentifier</b><br>
3462   * </p>
3463   */
3464  @SearchParamDefinition(name="related-id", path="Composition.relatesTo.target.as(Identifier)", description="Target of the relationship", type="token" )
3465  public static final String SP_RELATED_ID = "related-id";
3466 /**
3467   * <b>Fluent Client</b> search parameter constant for <b>related-id</b>
3468   * <p>
3469   * Description: <b>Target of the relationship</b><br>
3470   * Type: <b>token</b><br>
3471   * Path: <b>Composition.relatesTo.targetIdentifier</b><br>
3472   * </p>
3473   */
3474  public static final ca.uhn.fhir.rest.gclient.TokenClientParam RELATED_ID = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_RELATED_ID);
3475
3476 /**
3477   * Search parameter: <b>subject</b>
3478   * <p>
3479   * Description: <b>Who and/or what the composition is about</b><br>
3480   * Type: <b>reference</b><br>
3481   * Path: <b>Composition.subject</b><br>
3482   * </p>
3483   */
3484  @SearchParamDefinition(name="subject", path="Composition.subject", description="Who and/or what the composition is about", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
3485  public static final String SP_SUBJECT = "subject";
3486 /**
3487   * <b>Fluent Client</b> search parameter constant for <b>subject</b>
3488   * <p>
3489   * Description: <b>Who and/or what the composition is about</b><br>
3490   * Type: <b>reference</b><br>
3491   * Path: <b>Composition.subject</b><br>
3492   * </p>
3493   */
3494  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT);
3495
3496/**
3497   * Constant for fluent queries to be used to add include statements. Specifies
3498   * the path value of "<b>Composition:subject</b>".
3499   */
3500  public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("Composition:subject").toLocked();
3501
3502 /**
3503   * Search parameter: <b>author</b>
3504   * <p>
3505   * Description: <b>Who and/or what authored the composition</b><br>
3506   * Type: <b>reference</b><br>
3507   * Path: <b>Composition.author</b><br>
3508   * </p>
3509   */
3510  @SearchParamDefinition(name="author", path="Composition.author", description="Who and/or what authored the composition", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") }, target={Device.class, Patient.class, Practitioner.class, RelatedPerson.class } )
3511  public static final String SP_AUTHOR = "author";
3512 /**
3513   * <b>Fluent Client</b> search parameter constant for <b>author</b>
3514   * <p>
3515   * Description: <b>Who and/or what authored the composition</b><br>
3516   * Type: <b>reference</b><br>
3517   * Path: <b>Composition.author</b><br>
3518   * </p>
3519   */
3520  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam AUTHOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_AUTHOR);
3521
3522/**
3523   * Constant for fluent queries to be used to add include statements. Specifies
3524   * the path value of "<b>Composition:author</b>".
3525   */
3526  public static final ca.uhn.fhir.model.api.Include INCLUDE_AUTHOR = new ca.uhn.fhir.model.api.Include("Composition:author").toLocked();
3527
3528 /**
3529   * Search parameter: <b>confidentiality</b>
3530   * <p>
3531   * Description: <b>As defined by affinity domain</b><br>
3532   * Type: <b>token</b><br>
3533   * Path: <b>Composition.confidentiality</b><br>
3534   * </p>
3535   */
3536  @SearchParamDefinition(name="confidentiality", path="Composition.confidentiality", description="As defined by affinity domain", type="token" )
3537  public static final String SP_CONFIDENTIALITY = "confidentiality";
3538 /**
3539   * <b>Fluent Client</b> search parameter constant for <b>confidentiality</b>
3540   * <p>
3541   * Description: <b>As defined by affinity domain</b><br>
3542   * Type: <b>token</b><br>
3543   * Path: <b>Composition.confidentiality</b><br>
3544   * </p>
3545   */
3546  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONFIDENTIALITY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONFIDENTIALITY);
3547
3548 /**
3549   * Search parameter: <b>section</b>
3550   * <p>
3551   * Description: <b>Classification of section (recommended)</b><br>
3552   * Type: <b>token</b><br>
3553   * Path: <b>Composition.section.code</b><br>
3554   * </p>
3555   */
3556  @SearchParamDefinition(name="section", path="Composition.section.code", description="Classification of section (recommended)", type="token" )
3557  public static final String SP_SECTION = "section";
3558 /**
3559   * <b>Fluent Client</b> search parameter constant for <b>section</b>
3560   * <p>
3561   * Description: <b>Classification of section (recommended)</b><br>
3562   * Type: <b>token</b><br>
3563   * Path: <b>Composition.section.code</b><br>
3564   * </p>
3565   */
3566  public static final ca.uhn.fhir.rest.gclient.TokenClientParam SECTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SECTION);
3567
3568 /**
3569   * Search parameter: <b>encounter</b>
3570   * <p>
3571   * Description: <b>Context of the Composition</b><br>
3572   * Type: <b>reference</b><br>
3573   * Path: <b>Composition.encounter</b><br>
3574   * </p>
3575   */
3576  @SearchParamDefinition(name="encounter", path="Composition.encounter", description="Context of the Composition", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Encounter") }, target={Encounter.class } )
3577  public static final String SP_ENCOUNTER = "encounter";
3578 /**
3579   * <b>Fluent Client</b> search parameter constant for <b>encounter</b>
3580   * <p>
3581   * Description: <b>Context of the Composition</b><br>
3582   * Type: <b>reference</b><br>
3583   * Path: <b>Composition.encounter</b><br>
3584   * </p>
3585   */
3586  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ENCOUNTER);
3587
3588/**
3589   * Constant for fluent queries to be used to add include statements. Specifies
3590   * the path value of "<b>Composition:encounter</b>".
3591   */
3592  public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include("Composition:encounter").toLocked();
3593
3594 /**
3595   * Search parameter: <b>type</b>
3596   * <p>
3597   * Description: <b>Kind of composition (LOINC if possible)</b><br>
3598   * Type: <b>token</b><br>
3599   * Path: <b>Composition.type</b><br>
3600   * </p>
3601   */
3602  @SearchParamDefinition(name="type", path="Composition.type", description="Kind of composition (LOINC if possible)", type="token" )
3603  public static final String SP_TYPE = "type";
3604 /**
3605   * <b>Fluent Client</b> search parameter constant for <b>type</b>
3606   * <p>
3607   * Description: <b>Kind of composition (LOINC if possible)</b><br>
3608   * Type: <b>token</b><br>
3609   * Path: <b>Composition.type</b><br>
3610   * </p>
3611   */
3612  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
3613
3614 /**
3615   * Search parameter: <b>title</b>
3616   * <p>
3617   * Description: <b>Human Readable name/title</b><br>
3618   * Type: <b>string</b><br>
3619   * Path: <b>Composition.title</b><br>
3620   * </p>
3621   */
3622  @SearchParamDefinition(name="title", path="Composition.title", description="Human Readable name/title", type="string" )
3623  public static final String SP_TITLE = "title";
3624 /**
3625   * <b>Fluent Client</b> search parameter constant for <b>title</b>
3626   * <p>
3627   * Description: <b>Human Readable name/title</b><br>
3628   * Type: <b>string</b><br>
3629   * Path: <b>Composition.title</b><br>
3630   * </p>
3631   */
3632  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
3633
3634 /**
3635   * Search parameter: <b>attester</b>
3636   * <p>
3637   * Description: <b>Who attested the composition</b><br>
3638   * Type: <b>reference</b><br>
3639   * Path: <b>Composition.attester.party</b><br>
3640   * </p>
3641   */
3642  @SearchParamDefinition(name="attester", path="Composition.attester.party", description="Who attested the composition", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") }, target={Organization.class, Patient.class, Practitioner.class } )
3643  public static final String SP_ATTESTER = "attester";
3644 /**
3645   * <b>Fluent Client</b> search parameter constant for <b>attester</b>
3646   * <p>
3647   * Description: <b>Who attested the composition</b><br>
3648   * Type: <b>reference</b><br>
3649   * Path: <b>Composition.attester.party</b><br>
3650   * </p>
3651   */
3652  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ATTESTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ATTESTER);
3653
3654/**
3655   * Constant for fluent queries to be used to add include statements. Specifies
3656   * the path value of "<b>Composition:attester</b>".
3657   */
3658  public static final ca.uhn.fhir.model.api.Include INCLUDE_ATTESTER = new ca.uhn.fhir.model.api.Include("Composition:attester").toLocked();
3659
3660 /**
3661   * Search parameter: <b>entry</b>
3662   * <p>
3663   * Description: <b>A reference to data that supports this section</b><br>
3664   * Type: <b>reference</b><br>
3665   * Path: <b>Composition.section.entry</b><br>
3666   * </p>
3667   */
3668  @SearchParamDefinition(name="entry", path="Composition.section.entry", description="A reference to data that supports this section", type="reference" )
3669  public static final String SP_ENTRY = "entry";
3670 /**
3671   * <b>Fluent Client</b> search parameter constant for <b>entry</b>
3672   * <p>
3673   * Description: <b>A reference to data that supports this section</b><br>
3674   * Type: <b>reference</b><br>
3675   * Path: <b>Composition.section.entry</b><br>
3676   * </p>
3677   */
3678  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENTRY = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ENTRY);
3679
3680/**
3681   * Constant for fluent queries to be used to add include statements. Specifies
3682   * the path value of "<b>Composition:entry</b>".
3683   */
3684  public static final ca.uhn.fhir.model.api.Include INCLUDE_ENTRY = new ca.uhn.fhir.model.api.Include("Composition:entry").toLocked();
3685
3686 /**
3687   * Search parameter: <b>related-ref</b>
3688   * <p>
3689   * Description: <b>Target of the relationship</b><br>
3690   * Type: <b>reference</b><br>
3691   * Path: <b>Composition.relatesTo.targetReference</b><br>
3692   * </p>
3693   */
3694  @SearchParamDefinition(name="related-ref", path="Composition.relatesTo.target.as(Reference)", description="Target of the relationship", type="reference", target={Composition.class } )
3695  public static final String SP_RELATED_REF = "related-ref";
3696 /**
3697   * <b>Fluent Client</b> search parameter constant for <b>related-ref</b>
3698   * <p>
3699   * Description: <b>Target of the relationship</b><br>
3700   * Type: <b>reference</b><br>
3701   * Path: <b>Composition.relatesTo.targetReference</b><br>
3702   * </p>
3703   */
3704  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RELATED_REF = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RELATED_REF);
3705
3706/**
3707   * Constant for fluent queries to be used to add include statements. Specifies
3708   * the path value of "<b>Composition:related-ref</b>".
3709   */
3710  public static final ca.uhn.fhir.model.api.Include INCLUDE_RELATED_REF = new ca.uhn.fhir.model.api.Include("Composition:related-ref").toLocked();
3711
3712 /**
3713   * Search parameter: <b>patient</b>
3714   * <p>
3715   * Description: <b>Who and/or what the composition is about</b><br>
3716   * Type: <b>reference</b><br>
3717   * Path: <b>Composition.subject</b><br>
3718   * </p>
3719   */
3720  @SearchParamDefinition(name="patient", path="Composition.subject", description="Who and/or what the composition is about", type="reference", target={Patient.class } )
3721  public static final String SP_PATIENT = "patient";
3722 /**
3723   * <b>Fluent Client</b> search parameter constant for <b>patient</b>
3724   * <p>
3725   * Description: <b>Who and/or what the composition is about</b><br>
3726   * Type: <b>reference</b><br>
3727   * Path: <b>Composition.subject</b><br>
3728   * </p>
3729   */
3730  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT);
3731
3732/**
3733   * Constant for fluent queries to be used to add include statements. Specifies
3734   * the path value of "<b>Composition:patient</b>".
3735   */
3736  public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("Composition:patient").toLocked();
3737
3738 /**
3739   * Search parameter: <b>context</b>
3740   * <p>
3741   * Description: <b>Code(s) that apply to the event being documented</b><br>
3742   * Type: <b>token</b><br>
3743   * Path: <b>Composition.event.code</b><br>
3744   * </p>
3745   */
3746  @SearchParamDefinition(name="context", path="Composition.event.code", description="Code(s) that apply to the event being documented", type="token" )
3747  public static final String SP_CONTEXT = "context";
3748 /**
3749   * <b>Fluent Client</b> search parameter constant for <b>context</b>
3750   * <p>
3751   * Description: <b>Code(s) that apply to the event being documented</b><br>
3752   * Type: <b>token</b><br>
3753   * Path: <b>Composition.event.code</b><br>
3754   * </p>
3755   */
3756  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
3757
3758 /**
3759   * Search parameter: <b>class</b>
3760   * <p>
3761   * Description: <b>Categorization of Composition</b><br>
3762   * Type: <b>token</b><br>
3763   * Path: <b>Composition.class</b><br>
3764   * </p>
3765   */
3766  @SearchParamDefinition(name="class", path="Composition.class", description="Categorization of Composition", type="token" )
3767  public static final String SP_CLASS = "class";
3768 /**
3769   * <b>Fluent Client</b> search parameter constant for <b>class</b>
3770   * <p>
3771   * Description: <b>Categorization of Composition</b><br>
3772   * Type: <b>token</b><br>
3773   * Path: <b>Composition.class</b><br>
3774   * </p>
3775   */
3776  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CLASS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CLASS);
3777
3778 /**
3779   * Search parameter: <b>status</b>
3780   * <p>
3781   * Description: <b>preliminary | final | amended | entered-in-error</b><br>
3782   * Type: <b>token</b><br>
3783   * Path: <b>Composition.status</b><br>
3784   * </p>
3785   */
3786  @SearchParamDefinition(name="status", path="Composition.status", description="preliminary | final | amended | entered-in-error", type="token" )
3787  public static final String SP_STATUS = "status";
3788 /**
3789   * <b>Fluent Client</b> search parameter constant for <b>status</b>
3790   * <p>
3791   * Description: <b>preliminary | final | amended | entered-in-error</b><br>
3792   * Type: <b>token</b><br>
3793   * Path: <b>Composition.status</b><br>
3794   * </p>
3795   */
3796  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
3797
3798
3799}