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