package org.hl7.fhir.dstu2.formats;

import java.io.IOException;

/*
  Copyright (c) 2011+, HL7, Inc.
  All rights reserved.
  
  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:
  
   * Redistributions of source code must retain the above copyright notice, this 
     list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above copyright notice, 
     this list of conditions and the following disclaimer in the documentation 
     and/or other materials provided with the distribution.
   * Neither the name of HL7 nor the names of its contributors may be used to 
     endorse or promote products derived from this software without specific 
     prior written permission.
  
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
  POSSIBILITY OF SUCH DAMAGE.
  
*/

// Generated on Wed, Jul 13, 2016 05:32+1000 for FHIR v1.0.2
import org.hl7.fhir.dstu2.model.*;
import org.hl7.fhir.exceptions.FHIRFormatError;
import org.hl7.fhir.utilities.Utilities;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

public class JsonParser extends JsonParserBase {

  public JsonParser() {
    super();
  }

  public JsonParser(boolean allowUnknownContent) {
    super();
    setAllowUnknownContent(allowUnknownContent);
  }

  protected void parseElementProperties(JsonObject json, Element element) throws IOException, FHIRFormatError {
    super.parseElementProperties(json, element);
    if (json.has("extension")) {
      JsonArray array = json.getAsJsonArray("extension");
      for (int i = 0; i < array.size(); i++) {
        element.getExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    }
    ;
  }

  protected void parseBackboneProperties(JsonObject json, BackboneElement element) throws IOException, FHIRFormatError {
    parseElementProperties(json, element);
    if (json.has("modifierExtension")) {
      JsonArray array = json.getAsJsonArray("modifierExtension");
      for (int i = 0; i < array.size(); i++) {
        element.getModifierExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    }
  }

  protected void parseTypeProperties(JsonObject json, Element element) throws IOException, FHIRFormatError {
    parseElementProperties(json, element);
  }

  @SuppressWarnings("unchecked")
  protected <E extends Enum<E>> Enumeration<E> parseEnumeration(String s, E item, EnumFactory e)
      throws IOException, FHIRFormatError {
    Enumeration<E> res = new Enumeration<E>(e);
    if (s != null)
      res.setValue((E) e.fromCode(s));
    return res;
  }

  protected DateType parseDate(String v) throws IOException, FHIRFormatError {
    DateType res = new DateType(v);
    return res;
  }

  protected DateTimeType parseDateTime(String v) throws IOException, FHIRFormatError {
    DateTimeType res = new DateTimeType(v);
    return res;
  }

  protected CodeType parseCode(String v) throws IOException, FHIRFormatError {
    CodeType res = new CodeType(v);
    return res;
  }

  protected StringType parseString(String v) throws IOException, FHIRFormatError {
    StringType res = new StringType(v);
    return res;
  }

  protected IntegerType parseInteger(java.lang.Long v) throws IOException, FHIRFormatError {
    IntegerType res = new IntegerType(v);
    return res;
  }

  protected OidType parseOid(String v) throws IOException, FHIRFormatError {
    OidType res = new OidType(v);
    return res;
  }

  protected UriType parseUri(String v) throws IOException, FHIRFormatError {
    UriType res = new UriType(v);
    return res;
  }

  protected UuidType parseUuid(String v) throws IOException, FHIRFormatError {
    UuidType res = new UuidType(v);
    return res;
  }

  protected InstantType parseInstant(String v) throws IOException, FHIRFormatError {
    InstantType res = new InstantType(v);
    return res;
  }

  protected BooleanType parseBoolean(java.lang.Boolean v) throws IOException, FHIRFormatError {
    BooleanType res = new BooleanType(v);
    return res;
  }

  protected Base64BinaryType parseBase64Binary(String v) throws IOException, FHIRFormatError {
    Base64BinaryType res = new Base64BinaryType(v);
    return res;
  }

  protected UnsignedIntType parseUnsignedInt(String v) throws IOException, FHIRFormatError {
    UnsignedIntType res = new UnsignedIntType(v);
    return res;
  }

  protected MarkdownType parseMarkdown(String v) throws IOException, FHIRFormatError {
    MarkdownType res = new MarkdownType(v);
    return res;
  }

  protected TimeType parseTime(String v) throws IOException, FHIRFormatError {
    TimeType res = new TimeType(v);
    return res;
  }

  protected IdType parseId(String v) throws IOException, FHIRFormatError {
    IdType res = new IdType(v);
    return res;
  }

  protected PositiveIntType parsePositiveInt(String v) throws IOException, FHIRFormatError {
    PositiveIntType res = new PositiveIntType(v);
    return res;
  }

  protected DecimalType parseDecimal(java.math.BigDecimal v) throws IOException, FHIRFormatError {
    DecimalType res = new DecimalType(v);
    return res;
  }

  protected Extension parseExtension(JsonObject json) throws IOException, FHIRFormatError {
    Extension res = new Extension();
    parseElementProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    return res;
  }

  protected Narrative parseNarrative(JsonObject json) throws IOException, FHIRFormatError {
    Narrative res = new Narrative();
    parseElementProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Narrative.NarrativeStatus.NULL,
          new Narrative.NarrativeStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("div"))
      res.setDiv(parseXhtml(json.get("div").getAsString()));
    return res;
  }

  protected Identifier parseIdentifier(JsonObject json) throws IOException, FHIRFormatError {
    Identifier res = new Identifier();
    parseTypeProperties(json, res);
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Identifier.IdentifierUse.NULL,
          new Identifier.IdentifierUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("assigner"))
      res.setAssigner(parseReference(json.getAsJsonObject("assigner")));
    return res;
  }

  protected Coding parseCoding(JsonObject json) throws IOException, FHIRFormatError {
    Coding res = new Coding();
    parseTypeProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("userSelected"))
      res.setUserSelectedElement(parseBoolean(json.get("userSelected").getAsBoolean()));
    if (json.has("_userSelected"))
      parseElementProperties(json.getAsJsonObject("_userSelected"), res.getUserSelectedElement());
    return res;
  }

  protected Reference parseReference(JsonObject json) throws IOException, FHIRFormatError {
    Reference res = new Reference();
    parseTypeProperties(json, res);
    if (json.has("reference"))
      res.setReferenceElement(parseString(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(json.getAsJsonObject("_reference"), res.getReferenceElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    return res;
  }

  protected Signature parseSignature(JsonObject json) throws IOException, FHIRFormatError {
    Signature res = new Signature();
    parseTypeProperties(json, res);
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("when"))
      res.setWhenElement(parseInstant(json.get("when").getAsString()));
    if (json.has("_when"))
      parseElementProperties(json.getAsJsonObject("_when"), res.getWhenElement());
    Type who = parseType("who", json);
    if (who != null)
      res.setWho(who);
    if (json.has("contentType"))
      res.setContentTypeElement(parseCode(json.get("contentType").getAsString()));
    if (json.has("_contentType"))
      parseElementProperties(json.getAsJsonObject("_contentType"), res.getContentTypeElement());
    if (json.has("blob"))
      res.setBlobElement(parseBase64Binary(json.get("blob").getAsString()));
    if (json.has("_blob"))
      parseElementProperties(json.getAsJsonObject("_blob"), res.getBlobElement());
    return res;
  }

  protected SampledData parseSampledData(JsonObject json) throws IOException, FHIRFormatError {
    SampledData res = new SampledData();
    parseTypeProperties(json, res);
    if (json.has("origin"))
      res.setOrigin(parseSimpleQuantity(json.getAsJsonObject("origin")));
    if (json.has("period"))
      res.setPeriodElement(parseDecimal(json.get("period").getAsBigDecimal()));
    if (json.has("_period"))
      parseElementProperties(json.getAsJsonObject("_period"), res.getPeriodElement());
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("lowerLimit"))
      res.setLowerLimitElement(parseDecimal(json.get("lowerLimit").getAsBigDecimal()));
    if (json.has("_lowerLimit"))
      parseElementProperties(json.getAsJsonObject("_lowerLimit"), res.getLowerLimitElement());
    if (json.has("upperLimit"))
      res.setUpperLimitElement(parseDecimal(json.get("upperLimit").getAsBigDecimal()));
    if (json.has("_upperLimit"))
      parseElementProperties(json.getAsJsonObject("_upperLimit"), res.getUpperLimitElement());
    if (json.has("dimensions"))
      res.setDimensionsElement(parsePositiveInt(json.get("dimensions").getAsString()));
    if (json.has("_dimensions"))
      parseElementProperties(json.getAsJsonObject("_dimensions"), res.getDimensionsElement());
    if (json.has("data"))
      res.setDataElement(parseString(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(json.getAsJsonObject("_data"), res.getDataElement());
    return res;
  }

  protected Quantity parseQuantity(JsonObject json) throws IOException, FHIRFormatError {
    Quantity res = new Quantity();
    parseTypeProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Period parsePeriod(JsonObject json) throws IOException, FHIRFormatError {
    Period res = new Period();
    parseTypeProperties(json, res);
    if (json.has("start"))
      res.setStartElement(parseDateTime(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(json.getAsJsonObject("_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseDateTime(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(json.getAsJsonObject("_end"), res.getEndElement());
    return res;
  }

  protected Attachment parseAttachment(JsonObject json) throws IOException, FHIRFormatError {
    Attachment res = new Attachment();
    parseTypeProperties(json, res);
    if (json.has("contentType"))
      res.setContentTypeElement(parseCode(json.get("contentType").getAsString()));
    if (json.has("_contentType"))
      parseElementProperties(json.getAsJsonObject("_contentType"), res.getContentTypeElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(json.getAsJsonObject("_language"), res.getLanguageElement());
    if (json.has("data"))
      res.setDataElement(parseBase64Binary(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(json.getAsJsonObject("_data"), res.getDataElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("size"))
      res.setSizeElement(parseUnsignedInt(json.get("size").getAsString()));
    if (json.has("_size"))
      parseElementProperties(json.getAsJsonObject("_size"), res.getSizeElement());
    if (json.has("hash"))
      res.setHashElement(parseBase64Binary(json.get("hash").getAsString()));
    if (json.has("_hash"))
      parseElementProperties(json.getAsJsonObject("_hash"), res.getHashElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("creation"))
      res.setCreationElement(parseDateTime(json.get("creation").getAsString()));
    if (json.has("_creation"))
      parseElementProperties(json.getAsJsonObject("_creation"), res.getCreationElement());
    return res;
  }

  protected Ratio parseRatio(JsonObject json) throws IOException, FHIRFormatError {
    Ratio res = new Ratio();
    parseTypeProperties(json, res);
    if (json.has("numerator"))
      res.setNumerator(parseQuantity(json.getAsJsonObject("numerator")));
    if (json.has("denominator"))
      res.setDenominator(parseQuantity(json.getAsJsonObject("denominator")));
    return res;
  }

  protected Range parseRange(JsonObject json) throws IOException, FHIRFormatError {
    Range res = new Range();
    parseTypeProperties(json, res);
    if (json.has("low"))
      res.setLow(parseSimpleQuantity(json.getAsJsonObject("low")));
    if (json.has("high"))
      res.setHigh(parseSimpleQuantity(json.getAsJsonObject("high")));
    return res;
  }

  protected Annotation parseAnnotation(JsonObject json) throws IOException, FHIRFormatError {
    Annotation res = new Annotation();
    parseTypeProperties(json, res);
    Type author = parseType("author", json);
    if (author != null)
      res.setAuthor(author);
    if (json.has("time"))
      res.setTimeElement(parseDateTime(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(json.getAsJsonObject("_time"), res.getTimeElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected CodeableConcept parseCodeableConcept(JsonObject json) throws IOException, FHIRFormatError {
    CodeableConcept res = new CodeableConcept();
    parseTypeProperties(json, res);
    if (json.has("coding")) {
      JsonArray array = json.getAsJsonArray("coding");
      for (int i = 0; i < array.size(); i++) {
        res.getCoding().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected Money parseMoney(JsonObject json) throws IOException, FHIRFormatError {
    Money res = new Money();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected SimpleQuantity parseSimpleQuantity(JsonObject json) throws IOException, FHIRFormatError {
    SimpleQuantity res = new SimpleQuantity();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Duration parseDuration(JsonObject json) throws IOException, FHIRFormatError {
    Duration res = new Duration();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Count parseCount(JsonObject json) throws IOException, FHIRFormatError {
    Count res = new Count();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Distance parseDistance(JsonObject json) throws IOException, FHIRFormatError {
    Distance res = new Distance();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Age parseAge(JsonObject json) throws IOException, FHIRFormatError {
    Age res = new Age();
    parseElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), Quantity.QuantityComparator.NULL,
          new Quantity.QuantityComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(json.getAsJsonObject("_comparator"), res.getComparatorElement());
    if (json.has("unit"))
      res.setUnitElement(parseString(json.get("unit").getAsString()));
    if (json.has("_unit"))
      parseElementProperties(json.getAsJsonObject("_unit"), res.getUnitElement());
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected HumanName parseHumanName(JsonObject json) throws IOException, FHIRFormatError {
    HumanName res = new HumanName();
    parseElementProperties(json, res);
    if (json.has("use"))
      res.setUseElement(
          parseEnumeration(json.get("use").getAsString(), HumanName.NameUse.NULL, new HumanName.NameUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("family")) {
      JsonArray array = json.getAsJsonArray("family");
      for (int i = 0; i < array.size(); i++) {
        res.getFamily().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_family")) {
      JsonArray array = json.getAsJsonArray("_family");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getFamily().size())
          res.getFamily().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getFamily().get(i));
      }
    }
    ;
    if (json.has("given")) {
      JsonArray array = json.getAsJsonArray("given");
      for (int i = 0; i < array.size(); i++) {
        res.getGiven().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_given")) {
      JsonArray array = json.getAsJsonArray("_given");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getGiven().size())
          res.getGiven().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getGiven().get(i));
      }
    }
    ;
    if (json.has("prefix")) {
      JsonArray array = json.getAsJsonArray("prefix");
      for (int i = 0; i < array.size(); i++) {
        res.getPrefix().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_prefix")) {
      JsonArray array = json.getAsJsonArray("_prefix");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPrefix().size())
          res.getPrefix().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPrefix().get(i));
      }
    }
    ;
    if (json.has("suffix")) {
      JsonArray array = json.getAsJsonArray("suffix");
      for (int i = 0; i < array.size(); i++) {
        res.getSuffix().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_suffix")) {
      JsonArray array = json.getAsJsonArray("_suffix");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSuffix().size())
          res.getSuffix().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSuffix().get(i));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected ContactPoint parseContactPoint(JsonObject json) throws IOException, FHIRFormatError {
    ContactPoint res = new ContactPoint();
    parseElementProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseEnumeration(json.get("system").getAsString(), ContactPoint.ContactPointSystem.NULL,
          new ContactPoint.ContactPointSystemEnumFactory()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), ContactPoint.ContactPointUse.NULL,
          new ContactPoint.ContactPointUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("rank"))
      res.setRankElement(parsePositiveInt(json.get("rank").getAsString()));
    if (json.has("_rank"))
      parseElementProperties(json.getAsJsonObject("_rank"), res.getRankElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected Meta parseMeta(JsonObject json) throws IOException, FHIRFormatError {
    Meta res = new Meta();
    parseElementProperties(json, res);
    if (json.has("versionId"))
      res.setVersionIdElement(parseId(json.get("versionId").getAsString()));
    if (json.has("_versionId"))
      parseElementProperties(json.getAsJsonObject("_versionId"), res.getVersionIdElement());
    if (json.has("lastUpdated"))
      res.setLastUpdatedElement(parseInstant(json.get("lastUpdated").getAsString()));
    if (json.has("_lastUpdated"))
      parseElementProperties(json.getAsJsonObject("_lastUpdated"), res.getLastUpdatedElement());
    if (json.has("profile")) {
      JsonArray array = json.getAsJsonArray("profile");
      for (int i = 0; i < array.size(); i++) {
        res.getProfile().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_profile")) {
      JsonArray array = json.getAsJsonArray("_profile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProfile().size())
          res.getProfile().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProfile().get(i));
      }
    }
    ;
    if (json.has("security")) {
      JsonArray array = json.getAsJsonArray("security");
      for (int i = 0; i < array.size(); i++) {
        res.getSecurity().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("tag")) {
      JsonArray array = json.getAsJsonArray("tag");
      for (int i = 0; i < array.size(); i++) {
        res.getTag().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Address parseAddress(JsonObject json) throws IOException, FHIRFormatError {
    Address res = new Address();
    parseElementProperties(json, res);
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Address.AddressUse.NULL,
          new Address.AddressUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Address.AddressType.NULL,
          new Address.AddressTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("line")) {
      JsonArray array = json.getAsJsonArray("line");
      for (int i = 0; i < array.size(); i++) {
        res.getLine().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_line")) {
      JsonArray array = json.getAsJsonArray("_line");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getLine().size())
          res.getLine().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getLine().get(i));
      }
    }
    ;
    if (json.has("city"))
      res.setCityElement(parseString(json.get("city").getAsString()));
    if (json.has("_city"))
      parseElementProperties(json.getAsJsonObject("_city"), res.getCityElement());
    if (json.has("district"))
      res.setDistrictElement(parseString(json.get("district").getAsString()));
    if (json.has("_district"))
      parseElementProperties(json.getAsJsonObject("_district"), res.getDistrictElement());
    if (json.has("state"))
      res.setStateElement(parseString(json.get("state").getAsString()));
    if (json.has("_state"))
      parseElementProperties(json.getAsJsonObject("_state"), res.getStateElement());
    if (json.has("postalCode"))
      res.setPostalCodeElement(parseString(json.get("postalCode").getAsString()));
    if (json.has("_postalCode"))
      parseElementProperties(json.getAsJsonObject("_postalCode"), res.getPostalCodeElement());
    if (json.has("country"))
      res.setCountryElement(parseString(json.get("country").getAsString()));
    if (json.has("_country"))
      parseElementProperties(json.getAsJsonObject("_country"), res.getCountryElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected Timing parseTiming(JsonObject json) throws IOException, FHIRFormatError {
    Timing res = new Timing();
    parseElementProperties(json, res);
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseDateTime(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_event")) {
      JsonArray array = json.getAsJsonArray("_event");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getEvent().size())
          res.getEvent().add(parseDateTime(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getEvent().get(i));
      }
    }
    ;
    if (json.has("repeat"))
      res.setRepeat(parseTimingTimingRepeatComponent(json.getAsJsonObject("repeat"), res));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    return res;
  }

  protected Timing.TimingRepeatComponent parseTimingTimingRepeatComponent(JsonObject json, Timing owner)
      throws IOException, FHIRFormatError {
    Timing.TimingRepeatComponent res = new Timing.TimingRepeatComponent();
    parseElementProperties(json, res);
    Type bounds = parseType("bounds", json);
    if (bounds != null)
      res.setBounds(bounds);
    if (json.has("count"))
      res.setCountElement(parseInteger(json.get("count").getAsLong()));
    if (json.has("_count"))
      parseElementProperties(json.getAsJsonObject("_count"), res.getCountElement());
    if (json.has("duration"))
      res.setDurationElement(parseDecimal(json.get("duration").getAsBigDecimal()));
    if (json.has("_duration"))
      parseElementProperties(json.getAsJsonObject("_duration"), res.getDurationElement());
    if (json.has("durationMax"))
      res.setDurationMaxElement(parseDecimal(json.get("durationMax").getAsBigDecimal()));
    if (json.has("_durationMax"))
      parseElementProperties(json.getAsJsonObject("_durationMax"), res.getDurationMaxElement());
    if (json.has("durationUnits"))
      res.setDurationUnitsElement(parseEnumeration(json.get("durationUnits").getAsString(), Timing.UnitsOfTime.NULL,
          new Timing.UnitsOfTimeEnumFactory()));
    if (json.has("_durationUnits"))
      parseElementProperties(json.getAsJsonObject("_durationUnits"), res.getDurationUnitsElement());
    if (json.has("frequency"))
      res.setFrequencyElement(parseInteger(json.get("frequency").getAsLong()));
    if (json.has("_frequency"))
      parseElementProperties(json.getAsJsonObject("_frequency"), res.getFrequencyElement());
    if (json.has("frequencyMax"))
      res.setFrequencyMaxElement(parseInteger(json.get("frequencyMax").getAsLong()));
    if (json.has("_frequencyMax"))
      parseElementProperties(json.getAsJsonObject("_frequencyMax"), res.getFrequencyMaxElement());
    if (json.has("period"))
      res.setPeriodElement(parseDecimal(json.get("period").getAsBigDecimal()));
    if (json.has("_period"))
      parseElementProperties(json.getAsJsonObject("_period"), res.getPeriodElement());
    if (json.has("periodMax"))
      res.setPeriodMaxElement(parseDecimal(json.get("periodMax").getAsBigDecimal()));
    if (json.has("_periodMax"))
      parseElementProperties(json.getAsJsonObject("_periodMax"), res.getPeriodMaxElement());
    if (json.has("periodUnits"))
      res.setPeriodUnitsElement(parseEnumeration(json.get("periodUnits").getAsString(), Timing.UnitsOfTime.NULL,
          new Timing.UnitsOfTimeEnumFactory()));
    if (json.has("_periodUnits"))
      parseElementProperties(json.getAsJsonObject("_periodUnits"), res.getPeriodUnitsElement());
    if (json.has("when"))
      res.setWhenElement(parseEnumeration(json.get("when").getAsString(), Timing.EventTiming.NULL,
          new Timing.EventTimingEnumFactory()));
    if (json.has("_when"))
      parseElementProperties(json.getAsJsonObject("_when"), res.getWhenElement());
    return res;
  }

  protected ElementDefinition parseElementDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition res = new ElementDefinition();
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(json.getAsJsonObject("_path"), res.getPathElement());
    if (json.has("representation")) {
      JsonArray array = json.getAsJsonArray("representation");
      for (int i = 0; i < array.size(); i++) {
        res.getRepresentation().add(parseEnumeration(array.get(i).getAsString(),
            ElementDefinition.PropertyRepresentation.NULL, new ElementDefinition.PropertyRepresentationEnumFactory()));
      }
    }
    ;
    if (json.has("_representation")) {
      JsonArray array = json.getAsJsonArray("_representation");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getRepresentation().size())
          res.getRepresentation().add(parseEnumeration(null, ElementDefinition.PropertyRepresentation.NULL,
              new ElementDefinition.PropertyRepresentationEnumFactory()));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getRepresentation().get(i));
      }
    }
    ;
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(json.getAsJsonObject("_label"), res.getLabelElement());
    if (json.has("code")) {
      JsonArray array = json.getAsJsonArray("code");
      for (int i = 0; i < array.size(); i++) {
        res.getCode().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("slicing"))
      res.setSlicing(parseElementDefinitionElementDefinitionSlicingComponent(json.getAsJsonObject("slicing"), res));
    if (json.has("short"))
      res.setShortElement(parseString(json.get("short").getAsString()));
    if (json.has("_short"))
      parseElementProperties(json.getAsJsonObject("_short"), res.getShortElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseMarkdown(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(json.getAsJsonObject("_definition"), res.getDefinitionElement());
    if (json.has("comments"))
      res.setCommentsElement(parseMarkdown(json.get("comments").getAsString()));
    if (json.has("_comments"))
      parseElementProperties(json.getAsJsonObject("_comments"), res.getCommentsElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseMarkdown(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("alias")) {
      JsonArray array = json.getAsJsonArray("alias");
      for (int i = 0; i < array.size(); i++) {
        res.getAlias().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_alias")) {
      JsonArray array = json.getAsJsonArray("_alias");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getAlias().size())
          res.getAlias().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getAlias().get(i));
      }
    }
    ;
    if (json.has("min"))
      res.setMinElement(parseInteger(json.get("min").getAsLong()));
    if (json.has("_min"))
      parseElementProperties(json.getAsJsonObject("_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(json.getAsJsonObject("_max"), res.getMaxElement());
    if (json.has("base"))
      res.setBase(parseElementDefinitionElementDefinitionBaseComponent(json.getAsJsonObject("base"), res));
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseElementDefinitionTypeRefComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("nameReference"))
      res.setNameReferenceElement(parseString(json.get("nameReference").getAsString()));
    if (json.has("_nameReference"))
      parseElementProperties(json.getAsJsonObject("_nameReference"), res.getNameReferenceElement());
    Type defaultValue = parseType("defaultValue", json);
    if (defaultValue != null)
      res.setDefaultValue(defaultValue);
    if (json.has("meaningWhenMissing"))
      res.setMeaningWhenMissingElement(parseMarkdown(json.get("meaningWhenMissing").getAsString()));
    if (json.has("_meaningWhenMissing"))
      parseElementProperties(json.getAsJsonObject("_meaningWhenMissing"), res.getMeaningWhenMissingElement());
    Type fixed = parseType("fixed", json);
    if (fixed != null)
      res.setFixed(fixed);
    Type pattern = parseType("pattern", json);
    if (pattern != null)
      res.setPattern(pattern);
    Type example = parseType("example", json);
    if (example != null)
      res.setExample(example);
    Type minValue = parseType("minValue", json);
    if (minValue != null)
      res.setMinValue(minValue);
    Type maxValue = parseType("maxValue", json);
    if (maxValue != null)
      res.setMaxValue(maxValue);
    if (json.has("maxLength"))
      res.setMaxLengthElement(parseInteger(json.get("maxLength").getAsLong()));
    if (json.has("_maxLength"))
      parseElementProperties(json.getAsJsonObject("_maxLength"), res.getMaxLengthElement());
    if (json.has("condition")) {
      JsonArray array = json.getAsJsonArray("condition");
      for (int i = 0; i < array.size(); i++) {
        res.getCondition().add(parseId(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_condition")) {
      JsonArray array = json.getAsJsonArray("_condition");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getCondition().size())
          res.getCondition().add(parseId(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getCondition().get(i));
      }
    }
    ;
    if (json.has("constraint")) {
      JsonArray array = json.getAsJsonArray("constraint");
      for (int i = 0; i < array.size(); i++) {
        res.getConstraint()
            .add(parseElementDefinitionElementDefinitionConstraintComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("mustSupport"))
      res.setMustSupportElement(parseBoolean(json.get("mustSupport").getAsBoolean()));
    if (json.has("_mustSupport"))
      parseElementProperties(json.getAsJsonObject("_mustSupport"), res.getMustSupportElement());
    if (json.has("isModifier"))
      res.setIsModifierElement(parseBoolean(json.get("isModifier").getAsBoolean()));
    if (json.has("_isModifier"))
      parseElementProperties(json.getAsJsonObject("_isModifier"), res.getIsModifierElement());
    if (json.has("isSummary"))
      res.setIsSummaryElement(parseBoolean(json.get("isSummary").getAsBoolean()));
    if (json.has("_isSummary"))
      parseElementProperties(json.getAsJsonObject("_isSummary"), res.getIsSummaryElement());
    if (json.has("binding"))
      res.setBinding(parseElementDefinitionElementDefinitionBindingComponent(json.getAsJsonObject("binding"), res));
    if (json.has("mapping")) {
      JsonArray array = json.getAsJsonArray("mapping");
      for (int i = 0; i < array.size(); i++) {
        res.getMapping()
            .add(parseElementDefinitionElementDefinitionMappingComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ElementDefinition.ElementDefinitionSlicingComponent parseElementDefinitionElementDefinitionSlicingComponent(
      JsonObject json, ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionSlicingComponent res = new ElementDefinition.ElementDefinitionSlicingComponent();
    parseElementProperties(json, res);
    if (json.has("discriminator")) {
      JsonArray array = json.getAsJsonArray("discriminator");
      for (int i = 0; i < array.size(); i++) {
        res.getDiscriminator().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_discriminator")) {
      JsonArray array = json.getAsJsonArray("_discriminator");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDiscriminator().size())
          res.getDiscriminator().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDiscriminator().get(i));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("ordered"))
      res.setOrderedElement(parseBoolean(json.get("ordered").getAsBoolean()));
    if (json.has("_ordered"))
      parseElementProperties(json.getAsJsonObject("_ordered"), res.getOrderedElement());
    if (json.has("rules"))
      res.setRulesElement(parseEnumeration(json.get("rules").getAsString(), ElementDefinition.SlicingRules.NULL,
          new ElementDefinition.SlicingRulesEnumFactory()));
    if (json.has("_rules"))
      parseElementProperties(json.getAsJsonObject("_rules"), res.getRulesElement());
    return res;
  }

  protected ElementDefinition.ElementDefinitionBaseComponent parseElementDefinitionElementDefinitionBaseComponent(
      JsonObject json, ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionBaseComponent res = new ElementDefinition.ElementDefinitionBaseComponent();
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(json.getAsJsonObject("_path"), res.getPathElement());
    if (json.has("min"))
      res.setMinElement(parseInteger(json.get("min").getAsLong()));
    if (json.has("_min"))
      parseElementProperties(json.getAsJsonObject("_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(json.getAsJsonObject("_max"), res.getMaxElement());
    return res;
  }

  protected ElementDefinition.TypeRefComponent parseElementDefinitionTypeRefComponent(JsonObject json,
      ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.TypeRefComponent res = new ElementDefinition.TypeRefComponent();
    parseElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("profile")) {
      JsonArray array = json.getAsJsonArray("profile");
      for (int i = 0; i < array.size(); i++) {
        res.getProfile().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_profile")) {
      JsonArray array = json.getAsJsonArray("_profile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProfile().size())
          res.getProfile().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProfile().get(i));
      }
    }
    ;
    if (json.has("aggregation")) {
      JsonArray array = json.getAsJsonArray("aggregation");
      for (int i = 0; i < array.size(); i++) {
        res.getAggregation().add(parseEnumeration(array.get(i).getAsString(), ElementDefinition.AggregationMode.NULL,
            new ElementDefinition.AggregationModeEnumFactory()));
      }
    }
    ;
    if (json.has("_aggregation")) {
      JsonArray array = json.getAsJsonArray("_aggregation");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getAggregation().size())
          res.getAggregation().add(parseEnumeration(null, ElementDefinition.AggregationMode.NULL,
              new ElementDefinition.AggregationModeEnumFactory()));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getAggregation().get(i));
      }
    }
    ;
    return res;
  }

  protected ElementDefinition.ElementDefinitionConstraintComponent parseElementDefinitionElementDefinitionConstraintComponent(
      JsonObject json, ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionConstraintComponent res = new ElementDefinition.ElementDefinitionConstraintComponent();
    parseElementProperties(json, res);
    if (json.has("key"))
      res.setKeyElement(parseId(json.get("key").getAsString()));
    if (json.has("_key"))
      parseElementProperties(json.getAsJsonObject("_key"), res.getKeyElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("severity"))
      res.setSeverityElement(parseEnumeration(json.get("severity").getAsString(),
          ElementDefinition.ConstraintSeverity.NULL, new ElementDefinition.ConstraintSeverityEnumFactory()));
    if (json.has("_severity"))
      parseElementProperties(json.getAsJsonObject("_severity"), res.getSeverityElement());
    if (json.has("human"))
      res.setHumanElement(parseString(json.get("human").getAsString()));
    if (json.has("_human"))
      parseElementProperties(json.getAsJsonObject("_human"), res.getHumanElement());
    if (json.has("xpath"))
      res.setXpathElement(parseString(json.get("xpath").getAsString()));
    if (json.has("_xpath"))
      parseElementProperties(json.getAsJsonObject("_xpath"), res.getXpathElement());
    return res;
  }

  protected ElementDefinition.ElementDefinitionBindingComponent parseElementDefinitionElementDefinitionBindingComponent(
      JsonObject json, ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionBindingComponent res = new ElementDefinition.ElementDefinitionBindingComponent();
    parseElementProperties(json, res);
    if (json.has("strength"))
      res.setStrengthElement(parseEnumeration(json.get("strength").getAsString(), Enumerations.BindingStrength.NULL,
          new Enumerations.BindingStrengthEnumFactory()));
    if (json.has("_strength"))
      parseElementProperties(json.getAsJsonObject("_strength"), res.getStrengthElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    Type valueSet = parseType("valueSet", json);
    if (valueSet != null)
      res.setValueSet(valueSet);
    return res;
  }

  protected ElementDefinition.ElementDefinitionMappingComponent parseElementDefinitionElementDefinitionMappingComponent(
      JsonObject json, ElementDefinition owner) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionMappingComponent res = new ElementDefinition.ElementDefinitionMappingComponent();
    parseElementProperties(json, res);
    if (json.has("identity"))
      res.setIdentityElement(parseId(json.get("identity").getAsString()));
    if (json.has("_identity"))
      parseElementProperties(json.getAsJsonObject("_identity"), res.getIdentityElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(json.getAsJsonObject("_language"), res.getLanguageElement());
    if (json.has("map"))
      res.setMapElement(parseString(json.get("map").getAsString()));
    if (json.has("_map"))
      parseElementProperties(json.getAsJsonObject("_map"), res.getMapElement());
    return res;
  }

  protected void parseDomainResourceProperties(JsonObject json, DomainResource res)
      throws IOException, FHIRFormatError {
    parseResourceProperties(json, res);
    if (json.has("text"))
      res.setText(parseNarrative(json.getAsJsonObject("text")));
    if (json.has("contained")) {
      JsonArray array = json.getAsJsonArray("contained");
      for (int i = 0; i < array.size(); i++) {
        res.getContained().add(parseResource(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("extension")) {
      JsonArray array = json.getAsJsonArray("extension");
      for (int i = 0; i < array.size(); i++) {
        res.getExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("modifierExtension")) {
      JsonArray array = json.getAsJsonArray("modifierExtension");
      for (int i = 0; i < array.size(); i++) {
        res.getModifierExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    }
    ;
  }

  protected Parameters parseParameters(JsonObject json) throws IOException, FHIRFormatError {
    Parameters res = new Parameters();
    parseResourceProperties(json, res);
    if (json.has("parameter")) {
      JsonArray array = json.getAsJsonArray("parameter");
      for (int i = 0; i < array.size(); i++) {
        res.getParameter().add(parseParametersParametersParameterComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Parameters.ParametersParameterComponent parseParametersParametersParameterComponent(JsonObject json,
      Parameters owner) throws IOException, FHIRFormatError {
    Parameters.ParametersParameterComponent res = new Parameters.ParametersParameterComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("resource"))
      res.setResource(parseResource(json.getAsJsonObject("resource")));
    if (json.has("part")) {
      JsonArray array = json.getAsJsonArray("part");
      for (int i = 0; i < array.size(); i++) {
        res.getPart().add(parseParametersParametersParameterComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected void parseResourceProperties(JsonObject json, Resource res) throws IOException, FHIRFormatError {
    if (json.has("id"))
      res.setIdElement(parseId(json.get("id").getAsString()));
    if (json.has("_id"))
      parseElementProperties(json.getAsJsonObject("_id"), res.getIdElement());
    if (json.has("meta"))
      res.setMeta(parseMeta(json.getAsJsonObject("meta")));
    if (json.has("implicitRules"))
      res.setImplicitRulesElement(parseUri(json.get("implicitRules").getAsString()));
    if (json.has("_implicitRules"))
      parseElementProperties(json.getAsJsonObject("_implicitRules"), res.getImplicitRulesElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(json.getAsJsonObject("_language"), res.getLanguageElement());
  }

  protected Account parseAccount(JsonObject json) throws IOException, FHIRFormatError {
    Account res = new Account();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Account.AccountStatus.NULL,
          new Account.AccountStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("activePeriod"))
      res.setActivePeriod(parsePeriod(json.getAsJsonObject("activePeriod")));
    if (json.has("currency"))
      res.setCurrency(parseCoding(json.getAsJsonObject("currency")));
    if (json.has("balance"))
      res.setBalance(parseMoney(json.getAsJsonObject("balance")));
    if (json.has("coveragePeriod"))
      res.setCoveragePeriod(parsePeriod(json.getAsJsonObject("coveragePeriod")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("owner"))
      res.setOwner(parseReference(json.getAsJsonObject("owner")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    return res;
  }

  protected AllergyIntolerance parseAllergyIntolerance(JsonObject json) throws IOException, FHIRFormatError {
    AllergyIntolerance res = new AllergyIntolerance();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("onset"))
      res.setOnsetElement(parseDateTime(json.get("onset").getAsString()));
    if (json.has("_onset"))
      parseElementProperties(json.getAsJsonObject("_onset"), res.getOnsetElement());
    if (json.has("recordedDate"))
      res.setRecordedDateElement(parseDateTime(json.get("recordedDate").getAsString()));
    if (json.has("_recordedDate"))
      parseElementProperties(json.getAsJsonObject("_recordedDate"), res.getRecordedDateElement());
    if (json.has("recorder"))
      res.setRecorder(parseReference(json.getAsJsonObject("recorder")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("reporter"))
      res.setReporter(parseReference(json.getAsJsonObject("reporter")));
    if (json.has("substance"))
      res.setSubstance(parseCodeableConcept(json.getAsJsonObject("substance")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), AllergyIntolerance.AllergyIntoleranceStatus.NULL,
              new AllergyIntolerance.AllergyIntoleranceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("criticality"))
      res.setCriticalityElement(
          parseEnumeration(json.get("criticality").getAsString(), AllergyIntolerance.AllergyIntoleranceCriticality.NULL,
              new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory()));
    if (json.has("_criticality"))
      parseElementProperties(json.getAsJsonObject("_criticality"), res.getCriticalityElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(),
          AllergyIntolerance.AllergyIntoleranceType.NULL, new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("category"))
      res.setCategoryElement(
          parseEnumeration(json.get("category").getAsString(), AllergyIntolerance.AllergyIntoleranceCategory.NULL,
              new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory()));
    if (json.has("_category"))
      parseElementProperties(json.getAsJsonObject("_category"), res.getCategoryElement());
    if (json.has("lastOccurence"))
      res.setLastOccurenceElement(parseDateTime(json.get("lastOccurence").getAsString()));
    if (json.has("_lastOccurence"))
      parseElementProperties(json.getAsJsonObject("_lastOccurence"), res.getLastOccurenceElement());
    if (json.has("note"))
      res.setNote(parseAnnotation(json.getAsJsonObject("note")));
    if (json.has("reaction")) {
      JsonArray array = json.getAsJsonArray("reaction");
      for (int i = 0; i < array.size(); i++) {
        res.getReaction()
            .add(parseAllergyIntoleranceAllergyIntoleranceReactionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected AllergyIntolerance.AllergyIntoleranceReactionComponent parseAllergyIntoleranceAllergyIntoleranceReactionComponent(
      JsonObject json, AllergyIntolerance owner) throws IOException, FHIRFormatError {
    AllergyIntolerance.AllergyIntoleranceReactionComponent res = new AllergyIntolerance.AllergyIntoleranceReactionComponent();
    parseBackboneProperties(json, res);
    if (json.has("substance"))
      res.setSubstance(parseCodeableConcept(json.getAsJsonObject("substance")));
    if (json.has("certainty"))
      res.setCertaintyElement(
          parseEnumeration(json.get("certainty").getAsString(), AllergyIntolerance.AllergyIntoleranceCertainty.NULL,
              new AllergyIntolerance.AllergyIntoleranceCertaintyEnumFactory()));
    if (json.has("_certainty"))
      parseElementProperties(json.getAsJsonObject("_certainty"), res.getCertaintyElement());
    if (json.has("manifestation")) {
      JsonArray array = json.getAsJsonArray("manifestation");
      for (int i = 0; i < array.size(); i++) {
        res.getManifestation().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("onset"))
      res.setOnsetElement(parseDateTime(json.get("onset").getAsString()));
    if (json.has("_onset"))
      parseElementProperties(json.getAsJsonObject("_onset"), res.getOnsetElement());
    if (json.has("severity"))
      res.setSeverityElement(
          parseEnumeration(json.get("severity").getAsString(), AllergyIntolerance.AllergyIntoleranceSeverity.NULL,
              new AllergyIntolerance.AllergyIntoleranceSeverityEnumFactory()));
    if (json.has("_severity"))
      parseElementProperties(json.getAsJsonObject("_severity"), res.getSeverityElement());
    if (json.has("exposureRoute"))
      res.setExposureRoute(parseCodeableConcept(json.getAsJsonObject("exposureRoute")));
    if (json.has("note"))
      res.setNote(parseAnnotation(json.getAsJsonObject("note")));
    return res;
  }

  protected Appointment parseAppointment(JsonObject json) throws IOException, FHIRFormatError {
    Appointment res = new Appointment();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Appointment.AppointmentStatus.NULL,
          new Appointment.AppointmentStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(json.getAsJsonObject("reason")));
    if (json.has("priority"))
      res.setPriorityElement(parseUnsignedInt(json.get("priority").getAsString()));
    if (json.has("_priority"))
      parseElementProperties(json.getAsJsonObject("_priority"), res.getPriorityElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("start"))
      res.setStartElement(parseInstant(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(json.getAsJsonObject("_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(json.getAsJsonObject("_end"), res.getEndElement());
    if (json.has("minutesDuration"))
      res.setMinutesDurationElement(parsePositiveInt(json.get("minutesDuration").getAsString()));
    if (json.has("_minutesDuration"))
      parseElementProperties(json.getAsJsonObject("_minutesDuration"), res.getMinutesDurationElement());
    if (json.has("slot")) {
      JsonArray array = json.getAsJsonArray("slot");
      for (int i = 0; i < array.size(); i++) {
        res.getSlot().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    if (json.has("participant")) {
      JsonArray array = json.getAsJsonArray("participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseAppointmentAppointmentParticipantComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Appointment.AppointmentParticipantComponent parseAppointmentAppointmentParticipantComponent(JsonObject json,
      Appointment owner) throws IOException, FHIRFormatError {
    Appointment.AppointmentParticipantComponent res = new Appointment.AppointmentParticipantComponent();
    parseBackboneProperties(json, res);
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    if (json.has("required"))
      res.setRequiredElement(parseEnumeration(json.get("required").getAsString(), Appointment.ParticipantRequired.NULL,
          new Appointment.ParticipantRequiredEnumFactory()));
    if (json.has("_required"))
      parseElementProperties(json.getAsJsonObject("_required"), res.getRequiredElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Appointment.ParticipationStatus.NULL,
          new Appointment.ParticipationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    return res;
  }

  protected AppointmentResponse parseAppointmentResponse(JsonObject json) throws IOException, FHIRFormatError {
    AppointmentResponse res = new AppointmentResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("appointment"))
      res.setAppointment(parseReference(json.getAsJsonObject("appointment")));
    if (json.has("start"))
      res.setStartElement(parseInstant(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(json.getAsJsonObject("_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(json.getAsJsonObject("_end"), res.getEndElement());
    if (json.has("participantType")) {
      JsonArray array = json.getAsJsonArray("participantType");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipantType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    if (json.has("participantStatus"))
      res.setParticipantStatusElement(parseEnumeration(json.get("participantStatus").getAsString(),
          AppointmentResponse.ParticipantStatus.NULL, new AppointmentResponse.ParticipantStatusEnumFactory()));
    if (json.has("_participantStatus"))
      parseElementProperties(json.getAsJsonObject("_participantStatus"), res.getParticipantStatusElement());
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    return res;
  }

  protected AuditEvent parseAuditEvent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent res = new AuditEvent();
    parseDomainResourceProperties(json, res);
    if (json.has("event"))
      res.setEvent(parseAuditEventAuditEventEventComponent(json.getAsJsonObject("event"), res));
    if (json.has("participant")) {
      JsonArray array = json.getAsJsonArray("participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseAuditEventAuditEventParticipantComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("source"))
      res.setSource(parseAuditEventAuditEventSourceComponent(json.getAsJsonObject("source"), res));
    if (json.has("object")) {
      JsonArray array = json.getAsJsonArray("object");
      for (int i = 0; i < array.size(); i++) {
        res.getObject().add(parseAuditEventAuditEventObjectComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected AuditEvent.AuditEventEventComponent parseAuditEventAuditEventEventComponent(JsonObject json,
      AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventEventComponent res = new AuditEvent.AuditEventEventComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("subtype")) {
      JsonArray array = json.getAsJsonArray("subtype");
      for (int i = 0; i < array.size(); i++) {
        res.getSubtype().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("action"))
      res.setActionElement(parseEnumeration(json.get("action").getAsString(), AuditEvent.AuditEventAction.NULL,
          new AuditEvent.AuditEventActionEnumFactory()));
    if (json.has("_action"))
      parseElementProperties(json.getAsJsonObject("_action"), res.getActionElement());
    if (json.has("dateTime"))
      res.setDateTimeElement(parseInstant(json.get("dateTime").getAsString()));
    if (json.has("_dateTime"))
      parseElementProperties(json.getAsJsonObject("_dateTime"), res.getDateTimeElement());
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), AuditEvent.AuditEventOutcome.NULL,
          new AuditEvent.AuditEventOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("outcomeDesc"))
      res.setOutcomeDescElement(parseString(json.get("outcomeDesc").getAsString()));
    if (json.has("_outcomeDesc"))
      parseElementProperties(json.getAsJsonObject("_outcomeDesc"), res.getOutcomeDescElement());
    if (json.has("purposeOfEvent")) {
      JsonArray array = json.getAsJsonArray("purposeOfEvent");
      for (int i = 0; i < array.size(); i++) {
        res.getPurposeOfEvent().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected AuditEvent.AuditEventParticipantComponent parseAuditEventAuditEventParticipantComponent(JsonObject json,
      AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventParticipantComponent res = new AuditEvent.AuditEventParticipantComponent();
    parseBackboneProperties(json, res);
    if (json.has("role")) {
      JsonArray array = json.getAsJsonArray("role");
      for (int i = 0; i < array.size(); i++) {
        res.getRole().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reference"))
      res.setReference(parseReference(json.getAsJsonObject("reference")));
    if (json.has("userId"))
      res.setUserId(parseIdentifier(json.getAsJsonObject("userId")));
    if (json.has("altId"))
      res.setAltIdElement(parseString(json.get("altId").getAsString()));
    if (json.has("_altId"))
      parseElementProperties(json.getAsJsonObject("_altId"), res.getAltIdElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("requestor"))
      res.setRequestorElement(parseBoolean(json.get("requestor").getAsBoolean()));
    if (json.has("_requestor"))
      parseElementProperties(json.getAsJsonObject("_requestor"), res.getRequestorElement());
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("policy")) {
      JsonArray array = json.getAsJsonArray("policy");
      for (int i = 0; i < array.size(); i++) {
        res.getPolicy().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_policy")) {
      JsonArray array = json.getAsJsonArray("_policy");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPolicy().size())
          res.getPolicy().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPolicy().get(i));
      }
    }
    ;
    if (json.has("media"))
      res.setMedia(parseCoding(json.getAsJsonObject("media")));
    if (json.has("network"))
      res.setNetwork(parseAuditEventAuditEventParticipantNetworkComponent(json.getAsJsonObject("network"), owner));
    if (json.has("purposeOfUse")) {
      JsonArray array = json.getAsJsonArray("purposeOfUse");
      for (int i = 0; i < array.size(); i++) {
        res.getPurposeOfUse().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected AuditEvent.AuditEventParticipantNetworkComponent parseAuditEventAuditEventParticipantNetworkComponent(
      JsonObject json, AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventParticipantNetworkComponent res = new AuditEvent.AuditEventParticipantNetworkComponent();
    parseBackboneProperties(json, res);
    if (json.has("address"))
      res.setAddressElement(parseString(json.get("address").getAsString()));
    if (json.has("_address"))
      parseElementProperties(json.getAsJsonObject("_address"), res.getAddressElement());
    if (json.has("type"))
      res.setTypeElement(
          parseEnumeration(json.get("type").getAsString(), AuditEvent.AuditEventParticipantNetworkType.NULL,
              new AuditEvent.AuditEventParticipantNetworkTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    return res;
  }

  protected AuditEvent.AuditEventSourceComponent parseAuditEventAuditEventSourceComponent(JsonObject json,
      AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventSourceComponent res = new AuditEvent.AuditEventSourceComponent();
    parseBackboneProperties(json, res);
    if (json.has("site"))
      res.setSiteElement(parseString(json.get("site").getAsString()));
    if (json.has("_site"))
      parseElementProperties(json.getAsJsonObject("_site"), res.getSiteElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected AuditEvent.AuditEventObjectComponent parseAuditEventAuditEventObjectComponent(JsonObject json,
      AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventObjectComponent res = new AuditEvent.AuditEventObjectComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("reference"))
      res.setReference(parseReference(json.getAsJsonObject("reference")));
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("role"))
      res.setRole(parseCoding(json.getAsJsonObject("role")));
    if (json.has("lifecycle"))
      res.setLifecycle(parseCoding(json.getAsJsonObject("lifecycle")));
    if (json.has("securityLabel")) {
      JsonArray array = json.getAsJsonArray("securityLabel");
      for (int i = 0; i < array.size(); i++) {
        res.getSecurityLabel().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("query"))
      res.setQueryElement(parseBase64Binary(json.get("query").getAsString()));
    if (json.has("_query"))
      parseElementProperties(json.getAsJsonObject("_query"), res.getQueryElement());
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseAuditEventAuditEventObjectDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected AuditEvent.AuditEventObjectDetailComponent parseAuditEventAuditEventObjectDetailComponent(JsonObject json,
      AuditEvent owner) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventObjectDetailComponent res = new AuditEvent.AuditEventObjectDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseString(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("value"))
      res.setValueElement(parseBase64Binary(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected Basic parseBasic(JsonObject json) throws IOException, FHIRFormatError {
    Basic res = new Basic();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("created"))
      res.setCreatedElement(parseDate(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    return res;
  }

  protected Binary parseBinary(JsonObject json) throws IOException, FHIRFormatError {
    Binary res = new Binary();
    parseResourceProperties(json, res);
    if (json.has("contentType"))
      res.setContentTypeElement(parseCode(json.get("contentType").getAsString()));
    if (json.has("_contentType"))
      parseElementProperties(json.getAsJsonObject("_contentType"), res.getContentTypeElement());
    if (json.has("content"))
      res.setContentElement(parseBase64Binary(json.get("content").getAsString()));
    if (json.has("_content"))
      parseElementProperties(json.getAsJsonObject("_content"), res.getContentElement());
    return res;
  }

  protected BodySite parseBodySite(JsonObject json) throws IOException, FHIRFormatError {
    BodySite res = new BodySite();
    parseDomainResourceProperties(json, res);
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("modifier")) {
      JsonArray array = json.getAsJsonArray("modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("image")) {
      JsonArray array = json.getAsJsonArray("image");
      for (int i = 0; i < array.size(); i++) {
        res.getImage().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Bundle parseBundle(JsonObject json) throws IOException, FHIRFormatError {
    Bundle res = new Bundle();
    parseResourceProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(
          parseEnumeration(json.get("type").getAsString(), Bundle.BundleType.NULL, new Bundle.BundleTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("total"))
      res.setTotalElement(parseUnsignedInt(json.get("total").getAsString()));
    if (json.has("_total"))
      parseElementProperties(json.getAsJsonObject("_total"), res.getTotalElement());
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseBundleBundleLinkComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("entry")) {
      JsonArray array = json.getAsJsonArray("entry");
      for (int i = 0; i < array.size(); i++) {
        res.getEntry().add(parseBundleBundleEntryComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("signature"))
      res.setSignature(parseSignature(json.getAsJsonObject("signature")));
    return res;
  }

  protected Bundle.BundleLinkComponent parseBundleBundleLinkComponent(JsonObject json, Bundle owner)
      throws IOException, FHIRFormatError {
    Bundle.BundleLinkComponent res = new Bundle.BundleLinkComponent();
    parseBackboneProperties(json, res);
    if (json.has("relation"))
      res.setRelationElement(parseString(json.get("relation").getAsString()));
    if (json.has("_relation"))
      parseElementProperties(json.getAsJsonObject("_relation"), res.getRelationElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    return res;
  }

  protected Bundle.BundleEntryComponent parseBundleBundleEntryComponent(JsonObject json, Bundle owner)
      throws IOException, FHIRFormatError {
    Bundle.BundleEntryComponent res = new Bundle.BundleEntryComponent();
    parseBackboneProperties(json, res);
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseBundleBundleLinkComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("fullUrl"))
      res.setFullUrlElement(parseUri(json.get("fullUrl").getAsString()));
    if (json.has("_fullUrl"))
      parseElementProperties(json.getAsJsonObject("_fullUrl"), res.getFullUrlElement());
    if (json.has("resource"))
      res.setResource(parseResource(json.getAsJsonObject("resource")));
    if (json.has("search"))
      res.setSearch(parseBundleBundleEntrySearchComponent(json.getAsJsonObject("search"), owner));
    if (json.has("request"))
      res.setRequest(parseBundleBundleEntryRequestComponent(json.getAsJsonObject("request"), owner));
    if (json.has("response"))
      res.setResponse(parseBundleBundleEntryResponseComponent(json.getAsJsonObject("response"), owner));
    return res;
  }

  protected Bundle.BundleEntrySearchComponent parseBundleBundleEntrySearchComponent(JsonObject json, Bundle owner)
      throws IOException, FHIRFormatError {
    Bundle.BundleEntrySearchComponent res = new Bundle.BundleEntrySearchComponent();
    parseBackboneProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Bundle.SearchEntryMode.NULL,
          new Bundle.SearchEntryModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("score"))
      res.setScoreElement(parseDecimal(json.get("score").getAsBigDecimal()));
    if (json.has("_score"))
      parseElementProperties(json.getAsJsonObject("_score"), res.getScoreElement());
    return res;
  }

  protected Bundle.BundleEntryRequestComponent parseBundleBundleEntryRequestComponent(JsonObject json, Bundle owner)
      throws IOException, FHIRFormatError {
    Bundle.BundleEntryRequestComponent res = new Bundle.BundleEntryRequestComponent();
    parseBackboneProperties(json, res);
    if (json.has("method"))
      res.setMethodElement(
          parseEnumeration(json.get("method").getAsString(), Bundle.HTTPVerb.NULL, new Bundle.HTTPVerbEnumFactory()));
    if (json.has("_method"))
      parseElementProperties(json.getAsJsonObject("_method"), res.getMethodElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("ifNoneMatch"))
      res.setIfNoneMatchElement(parseString(json.get("ifNoneMatch").getAsString()));
    if (json.has("_ifNoneMatch"))
      parseElementProperties(json.getAsJsonObject("_ifNoneMatch"), res.getIfNoneMatchElement());
    if (json.has("ifModifiedSince"))
      res.setIfModifiedSinceElement(parseInstant(json.get("ifModifiedSince").getAsString()));
    if (json.has("_ifModifiedSince"))
      parseElementProperties(json.getAsJsonObject("_ifModifiedSince"), res.getIfModifiedSinceElement());
    if (json.has("ifMatch"))
      res.setIfMatchElement(parseString(json.get("ifMatch").getAsString()));
    if (json.has("_ifMatch"))
      parseElementProperties(json.getAsJsonObject("_ifMatch"), res.getIfMatchElement());
    if (json.has("ifNoneExist"))
      res.setIfNoneExistElement(parseString(json.get("ifNoneExist").getAsString()));
    if (json.has("_ifNoneExist"))
      parseElementProperties(json.getAsJsonObject("_ifNoneExist"), res.getIfNoneExistElement());
    return res;
  }

  protected Bundle.BundleEntryResponseComponent parseBundleBundleEntryResponseComponent(JsonObject json, Bundle owner)
      throws IOException, FHIRFormatError {
    Bundle.BundleEntryResponseComponent res = new Bundle.BundleEntryResponseComponent();
    parseBackboneProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseString(json.get("status").getAsString()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("location"))
      res.setLocationElement(parseUri(json.get("location").getAsString()));
    if (json.has("_location"))
      parseElementProperties(json.getAsJsonObject("_location"), res.getLocationElement());
    if (json.has("etag"))
      res.setEtagElement(parseString(json.get("etag").getAsString()));
    if (json.has("_etag"))
      parseElementProperties(json.getAsJsonObject("_etag"), res.getEtagElement());
    if (json.has("lastModified"))
      res.setLastModifiedElement(parseInstant(json.get("lastModified").getAsString()));
    if (json.has("_lastModified"))
      parseElementProperties(json.getAsJsonObject("_lastModified"), res.getLastModifiedElement());
    return res;
  }

  protected CarePlan parseCarePlan(JsonObject json) throws IOException, FHIRFormatError {
    CarePlan res = new CarePlan();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), CarePlan.CarePlanStatus.NULL,
          new CarePlan.CarePlanStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("context"))
      res.setContext(parseReference(json.getAsJsonObject("context")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("author")) {
      JsonArray array = json.getAsJsonArray("author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("modified"))
      res.setModifiedElement(parseDateTime(json.get("modified").getAsString()));
    if (json.has("_modified"))
      parseElementProperties(json.getAsJsonObject("_modified"), res.getModifiedElement());
    if (json.has("category")) {
      JsonArray array = json.getAsJsonArray("category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("addresses")) {
      JsonArray array = json.getAsJsonArray("addresses");
      for (int i = 0; i < array.size(); i++) {
        res.getAddresses().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("support")) {
      JsonArray array = json.getAsJsonArray("support");
      for (int i = 0; i < array.size(); i++) {
        res.getSupport().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("relatedPlan")) {
      JsonArray array = json.getAsJsonArray("relatedPlan");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedPlan().add(parseCarePlanCarePlanRelatedPlanComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("participant")) {
      JsonArray array = json.getAsJsonArray("participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseCarePlanCarePlanParticipantComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("goal")) {
      JsonArray array = json.getAsJsonArray("goal");
      for (int i = 0; i < array.size(); i++) {
        res.getGoal().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("activity")) {
      JsonArray array = json.getAsJsonArray("activity");
      for (int i = 0; i < array.size(); i++) {
        res.getActivity().add(parseCarePlanCarePlanActivityComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("note"))
      res.setNote(parseAnnotation(json.getAsJsonObject("note")));
    return res;
  }

  protected CarePlan.CarePlanRelatedPlanComponent parseCarePlanCarePlanRelatedPlanComponent(JsonObject json,
      CarePlan owner) throws IOException, FHIRFormatError {
    CarePlan.CarePlanRelatedPlanComponent res = new CarePlan.CarePlanRelatedPlanComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), CarePlan.CarePlanRelationship.NULL,
          new CarePlan.CarePlanRelationshipEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("plan"))
      res.setPlan(parseReference(json.getAsJsonObject("plan")));
    return res;
  }

  protected CarePlan.CarePlanParticipantComponent parseCarePlanCarePlanParticipantComponent(JsonObject json,
      CarePlan owner) throws IOException, FHIRFormatError {
    CarePlan.CarePlanParticipantComponent res = new CarePlan.CarePlanParticipantComponent();
    parseBackboneProperties(json, res);
    if (json.has("role"))
      res.setRole(parseCodeableConcept(json.getAsJsonObject("role")));
    if (json.has("member"))
      res.setMember(parseReference(json.getAsJsonObject("member")));
    return res;
  }

  protected CarePlan.CarePlanActivityComponent parseCarePlanCarePlanActivityComponent(JsonObject json, CarePlan owner)
      throws IOException, FHIRFormatError {
    CarePlan.CarePlanActivityComponent res = new CarePlan.CarePlanActivityComponent();
    parseBackboneProperties(json, res);
    if (json.has("actionResulting")) {
      JsonArray array = json.getAsJsonArray("actionResulting");
      for (int i = 0; i < array.size(); i++) {
        res.getActionResulting().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("progress")) {
      JsonArray array = json.getAsJsonArray("progress");
      for (int i = 0; i < array.size(); i++) {
        res.getProgress().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reference"))
      res.setReference(parseReference(json.getAsJsonObject("reference")));
    if (json.has("detail"))
      res.setDetail(parseCarePlanCarePlanActivityDetailComponent(json.getAsJsonObject("detail"), owner));
    return res;
  }

  protected CarePlan.CarePlanActivityDetailComponent parseCarePlanCarePlanActivityDetailComponent(JsonObject json,
      CarePlan owner) throws IOException, FHIRFormatError {
    CarePlan.CarePlanActivityDetailComponent res = new CarePlan.CarePlanActivityDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("reasonCode")) {
      JsonArray array = json.getAsJsonArray("reasonCode");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reasonReference")) {
      JsonArray array = json.getAsJsonArray("reasonReference");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonReference().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("goal")) {
      JsonArray array = json.getAsJsonArray("goal");
      for (int i = 0; i < array.size(); i++) {
        res.getGoal().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), CarePlan.CarePlanActivityStatus.NULL,
          new CarePlan.CarePlanActivityStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(json.getAsJsonObject("statusReason")));
    if (json.has("prohibited"))
      res.setProhibitedElement(parseBoolean(json.get("prohibited").getAsBoolean()));
    if (json.has("_prohibited"))
      parseElementProperties(json.getAsJsonObject("_prohibited"), res.getProhibitedElement());
    Type scheduled = parseType("scheduled", json);
    if (scheduled != null)
      res.setScheduled(scheduled);
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("performer")) {
      JsonArray array = json.getAsJsonArray("performer");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformer().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type product = parseType("product", json);
    if (product != null)
      res.setProduct(product);
    if (json.has("dailyAmount"))
      res.setDailyAmount(parseSimpleQuantity(json.getAsJsonObject("dailyAmount")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    return res;
  }

  protected Claim parseClaim(JsonObject json) throws IOException, FHIRFormatError {
    Claim res = new Claim();
    parseDomainResourceProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(
          parseEnumeration(json.get("type").getAsString(), Claim.ClaimType.NULL, new Claim.ClaimTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Claim.Use.NULL, new Claim.UseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("priority"))
      res.setPriority(parseCoding(json.getAsJsonObject("priority")));
    if (json.has("fundsReserve"))
      res.setFundsReserve(parseCoding(json.getAsJsonObject("fundsReserve")));
    if (json.has("enterer"))
      res.setEnterer(parseReference(json.getAsJsonObject("enterer")));
    if (json.has("facility"))
      res.setFacility(parseReference(json.getAsJsonObject("facility")));
    if (json.has("prescription"))
      res.setPrescription(parseReference(json.getAsJsonObject("prescription")));
    if (json.has("originalPrescription"))
      res.setOriginalPrescription(parseReference(json.getAsJsonObject("originalPrescription")));
    if (json.has("payee"))
      res.setPayee(parseClaimPayeeComponent(json.getAsJsonObject("payee"), res));
    if (json.has("referral"))
      res.setReferral(parseReference(json.getAsJsonObject("referral")));
    if (json.has("diagnosis")) {
      JsonArray array = json.getAsJsonArray("diagnosis");
      for (int i = 0; i < array.size(); i++) {
        res.getDiagnosis().add(parseClaimDiagnosisComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("condition")) {
      JsonArray array = json.getAsJsonArray("condition");
      for (int i = 0; i < array.size(); i++) {
        res.getCondition().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("coverage")) {
      JsonArray array = json.getAsJsonArray("coverage");
      for (int i = 0; i < array.size(); i++) {
        res.getCoverage().add(parseClaimCoverageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("exception")) {
      JsonArray array = json.getAsJsonArray("exception");
      for (int i = 0; i < array.size(); i++) {
        res.getException().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("school"))
      res.setSchoolElement(parseString(json.get("school").getAsString()));
    if (json.has("_school"))
      parseElementProperties(json.getAsJsonObject("_school"), res.getSchoolElement());
    if (json.has("accident"))
      res.setAccidentElement(parseDate(json.get("accident").getAsString()));
    if (json.has("_accident"))
      parseElementProperties(json.getAsJsonObject("_accident"), res.getAccidentElement());
    if (json.has("accidentType"))
      res.setAccidentType(parseCoding(json.getAsJsonObject("accidentType")));
    if (json.has("interventionException")) {
      JsonArray array = json.getAsJsonArray("interventionException");
      for (int i = 0; i < array.size(); i++) {
        res.getInterventionException().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("item")) {
      JsonArray array = json.getAsJsonArray("item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseClaimItemsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("additionalMaterials")) {
      JsonArray array = json.getAsJsonArray("additionalMaterials");
      for (int i = 0; i < array.size(); i++) {
        res.getAdditionalMaterials().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("missingTeeth")) {
      JsonArray array = json.getAsJsonArray("missingTeeth");
      for (int i = 0; i < array.size(); i++) {
        res.getMissingTeeth().add(parseClaimMissingTeethComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Claim.PayeeComponent parseClaimPayeeComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.PayeeComponent res = new Claim.PayeeComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("person"))
      res.setPerson(parseReference(json.getAsJsonObject("person")));
    return res;
  }

  protected Claim.DiagnosisComponent parseClaimDiagnosisComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.DiagnosisComponent res = new Claim.DiagnosisComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("diagnosis"))
      res.setDiagnosis(parseCoding(json.getAsJsonObject("diagnosis")));
    return res;
  }

  protected Claim.CoverageComponent parseClaimCoverageComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.CoverageComponent res = new Claim.CoverageComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("focal"))
      res.setFocalElement(parseBoolean(json.get("focal").getAsBoolean()));
    if (json.has("_focal"))
      parseElementProperties(json.getAsJsonObject("_focal"), res.getFocalElement());
    if (json.has("coverage"))
      res.setCoverage(parseReference(json.getAsJsonObject("coverage")));
    if (json.has("businessArrangement"))
      res.setBusinessArrangementElement(parseString(json.get("businessArrangement").getAsString()));
    if (json.has("_businessArrangement"))
      parseElementProperties(json.getAsJsonObject("_businessArrangement"), res.getBusinessArrangementElement());
    if (json.has("relationship"))
      res.setRelationship(parseCoding(json.getAsJsonObject("relationship")));
    if (json.has("preAuthRef")) {
      JsonArray array = json.getAsJsonArray("preAuthRef");
      for (int i = 0; i < array.size(); i++) {
        res.getPreAuthRef().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_preAuthRef")) {
      JsonArray array = json.getAsJsonArray("_preAuthRef");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPreAuthRef().size())
          res.getPreAuthRef().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPreAuthRef().get(i));
      }
    }
    ;
    if (json.has("claimResponse"))
      res.setClaimResponse(parseReference(json.getAsJsonObject("claimResponse")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    return res;
  }

  protected Claim.ItemsComponent parseClaimItemsComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.ItemsComponent res = new Claim.ItemsComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("diagnosisLinkId")) {
      JsonArray array = json.getAsJsonArray("diagnosisLinkId");
      for (int i = 0; i < array.size(); i++) {
        res.getDiagnosisLinkId().add(parsePositiveInt(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_diagnosisLinkId")) {
      JsonArray array = json.getAsJsonArray("_diagnosisLinkId");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDiagnosisLinkId().size())
          res.getDiagnosisLinkId().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDiagnosisLinkId().get(i));
      }
    }
    ;
    if (json.has("service"))
      res.setService(parseCoding(json.getAsJsonObject("service")));
    if (json.has("serviceDate"))
      res.setServiceDateElement(parseDate(json.get("serviceDate").getAsString()));
    if (json.has("_serviceDate"))
      parseElementProperties(json.getAsJsonObject("_serviceDate"), res.getServiceDateElement());
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(json.getAsJsonObject("unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("points"))
      res.setPointsElement(parseDecimal(json.get("points").getAsBigDecimal()));
    if (json.has("_points"))
      parseElementProperties(json.getAsJsonObject("_points"), res.getPointsElement());
    if (json.has("net"))
      res.setNet(parseMoney(json.getAsJsonObject("net")));
    if (json.has("udi"))
      res.setUdi(parseCoding(json.getAsJsonObject("udi")));
    if (json.has("bodySite"))
      res.setBodySite(parseCoding(json.getAsJsonObject("bodySite")));
    if (json.has("subSite")) {
      JsonArray array = json.getAsJsonArray("subSite");
      for (int i = 0; i < array.size(); i++) {
        res.getSubSite().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("modifier")) {
      JsonArray array = json.getAsJsonArray("modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("prosthesis"))
      res.setProsthesis(parseClaimProsthesisComponent(json.getAsJsonObject("prosthesis"), owner));
    return res;
  }

  protected Claim.DetailComponent parseClaimDetailComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.DetailComponent res = new Claim.DetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("service"))
      res.setService(parseCoding(json.getAsJsonObject("service")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(json.getAsJsonObject("unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("points"))
      res.setPointsElement(parseDecimal(json.get("points").getAsBigDecimal()));
    if (json.has("_points"))
      parseElementProperties(json.getAsJsonObject("_points"), res.getPointsElement());
    if (json.has("net"))
      res.setNet(parseMoney(json.getAsJsonObject("net")));
    if (json.has("udi"))
      res.setUdi(parseCoding(json.getAsJsonObject("udi")));
    if (json.has("subDetail")) {
      JsonArray array = json.getAsJsonArray("subDetail");
      for (int i = 0; i < array.size(); i++) {
        res.getSubDetail().add(parseClaimSubDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Claim.SubDetailComponent parseClaimSubDetailComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.SubDetailComponent res = new Claim.SubDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("service"))
      res.setService(parseCoding(json.getAsJsonObject("service")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(json.getAsJsonObject("unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("points"))
      res.setPointsElement(parseDecimal(json.get("points").getAsBigDecimal()));
    if (json.has("_points"))
      parseElementProperties(json.getAsJsonObject("_points"), res.getPointsElement());
    if (json.has("net"))
      res.setNet(parseMoney(json.getAsJsonObject("net")));
    if (json.has("udi"))
      res.setUdi(parseCoding(json.getAsJsonObject("udi")));
    return res;
  }

  protected Claim.ProsthesisComponent parseClaimProsthesisComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.ProsthesisComponent res = new Claim.ProsthesisComponent();
    parseBackboneProperties(json, res);
    if (json.has("initial"))
      res.setInitialElement(parseBoolean(json.get("initial").getAsBoolean()));
    if (json.has("_initial"))
      parseElementProperties(json.getAsJsonObject("_initial"), res.getInitialElement());
    if (json.has("priorDate"))
      res.setPriorDateElement(parseDate(json.get("priorDate").getAsString()));
    if (json.has("_priorDate"))
      parseElementProperties(json.getAsJsonObject("_priorDate"), res.getPriorDateElement());
    if (json.has("priorMaterial"))
      res.setPriorMaterial(parseCoding(json.getAsJsonObject("priorMaterial")));
    return res;
  }

  protected Claim.MissingTeethComponent parseClaimMissingTeethComponent(JsonObject json, Claim owner)
      throws IOException, FHIRFormatError {
    Claim.MissingTeethComponent res = new Claim.MissingTeethComponent();
    parseBackboneProperties(json, res);
    if (json.has("tooth"))
      res.setTooth(parseCoding(json.getAsJsonObject("tooth")));
    if (json.has("reason"))
      res.setReason(parseCoding(json.getAsJsonObject("reason")));
    if (json.has("extractionDate"))
      res.setExtractionDateElement(parseDate(json.get("extractionDate").getAsString()));
    if (json.has("_extractionDate"))
      parseElementProperties(json.getAsJsonObject("_extractionDate"), res.getExtractionDateElement());
    return res;
  }

  protected ClaimResponse parseClaimResponse(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse res = new ClaimResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.RemittanceOutcome.NULL,
          new Enumerations.RemittanceOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("payeeType"))
      res.setPayeeType(parseCoding(json.getAsJsonObject("payeeType")));
    if (json.has("item")) {
      JsonArray array = json.getAsJsonArray("item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseClaimResponseItemsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("addItem")) {
      JsonArray array = json.getAsJsonArray("addItem");
      for (int i = 0; i < array.size(); i++) {
        res.getAddItem().add(parseClaimResponseAddedItemComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("error")) {
      JsonArray array = json.getAsJsonArray("error");
      for (int i = 0; i < array.size(); i++) {
        res.getError().add(parseClaimResponseErrorsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("totalCost"))
      res.setTotalCost(parseMoney(json.getAsJsonObject("totalCost")));
    if (json.has("unallocDeductable"))
      res.setUnallocDeductable(parseMoney(json.getAsJsonObject("unallocDeductable")));
    if (json.has("totalBenefit"))
      res.setTotalBenefit(parseMoney(json.getAsJsonObject("totalBenefit")));
    if (json.has("paymentAdjustment"))
      res.setPaymentAdjustment(parseMoney(json.getAsJsonObject("paymentAdjustment")));
    if (json.has("paymentAdjustmentReason"))
      res.setPaymentAdjustmentReason(parseCoding(json.getAsJsonObject("paymentAdjustmentReason")));
    if (json.has("paymentDate"))
      res.setPaymentDateElement(parseDate(json.get("paymentDate").getAsString()));
    if (json.has("_paymentDate"))
      parseElementProperties(json.getAsJsonObject("_paymentDate"), res.getPaymentDateElement());
    if (json.has("paymentAmount"))
      res.setPaymentAmount(parseMoney(json.getAsJsonObject("paymentAmount")));
    if (json.has("paymentRef"))
      res.setPaymentRef(parseIdentifier(json.getAsJsonObject("paymentRef")));
    if (json.has("reserved"))
      res.setReserved(parseCoding(json.getAsJsonObject("reserved")));
    if (json.has("form"))
      res.setForm(parseCoding(json.getAsJsonObject("form")));
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseClaimResponseNotesComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("coverage")) {
      JsonArray array = json.getAsJsonArray("coverage");
      for (int i = 0; i < array.size(); i++) {
        res.getCoverage().add(parseClaimResponseCoverageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.ItemsComponent parseClaimResponseItemsComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.ItemsComponent res = new ClaimResponse.ItemsComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId"))
      res.setSequenceLinkIdElement(parsePositiveInt(json.get("sequenceLinkId").getAsString()));
    if (json.has("_sequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_sequenceLinkId"), res.getSequenceLinkIdElement());
    if (json.has("noteNumber")) {
      JsonArray array = json.getAsJsonArray("noteNumber");
      for (int i = 0; i < array.size(); i++) {
        res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_noteNumber")) {
      JsonArray array = json.getAsJsonArray("_noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getNoteNumber().size())
          res.getNoteNumber().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getNoteNumber().get(i));
      }
    }
    ;
    if (json.has("adjudication")) {
      JsonArray array = json.getAsJsonArray("adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseItemAdjudicationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimResponseItemDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.ItemAdjudicationComponent parseClaimResponseItemAdjudicationComponent(JsonObject json,
      ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.ItemAdjudicationComponent res = new ClaimResponse.ItemAdjudicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ClaimResponse.ItemDetailComponent parseClaimResponseItemDetailComponent(JsonObject json,
      ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.ItemDetailComponent res = new ClaimResponse.ItemDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId"))
      res.setSequenceLinkIdElement(parsePositiveInt(json.get("sequenceLinkId").getAsString()));
    if (json.has("_sequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_sequenceLinkId"), res.getSequenceLinkIdElement());
    if (json.has("adjudication")) {
      JsonArray array = json.getAsJsonArray("adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseDetailAdjudicationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("subDetail")) {
      JsonArray array = json.getAsJsonArray("subDetail");
      for (int i = 0; i < array.size(); i++) {
        res.getSubDetail().add(parseClaimResponseSubDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.DetailAdjudicationComponent parseClaimResponseDetailAdjudicationComponent(JsonObject json,
      ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.DetailAdjudicationComponent res = new ClaimResponse.DetailAdjudicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ClaimResponse.SubDetailComponent parseClaimResponseSubDetailComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.SubDetailComponent res = new ClaimResponse.SubDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId"))
      res.setSequenceLinkIdElement(parsePositiveInt(json.get("sequenceLinkId").getAsString()));
    if (json.has("_sequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_sequenceLinkId"), res.getSequenceLinkIdElement());
    if (json.has("adjudication")) {
      JsonArray array = json.getAsJsonArray("adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication()
            .add(parseClaimResponseSubdetailAdjudicationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.SubdetailAdjudicationComponent parseClaimResponseSubdetailAdjudicationComponent(
      JsonObject json, ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.SubdetailAdjudicationComponent res = new ClaimResponse.SubdetailAdjudicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ClaimResponse.AddedItemComponent parseClaimResponseAddedItemComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemComponent res = new ClaimResponse.AddedItemComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId")) {
      JsonArray array = json.getAsJsonArray("sequenceLinkId");
      for (int i = 0; i < array.size(); i++) {
        res.getSequenceLinkId().add(parsePositiveInt(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_sequenceLinkId")) {
      JsonArray array = json.getAsJsonArray("_sequenceLinkId");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSequenceLinkId().size())
          res.getSequenceLinkId().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSequenceLinkId().get(i));
      }
    }
    ;
    if (json.has("service"))
      res.setService(parseCoding(json.getAsJsonObject("service")));
    if (json.has("fee"))
      res.setFee(parseMoney(json.getAsJsonObject("fee")));
    if (json.has("noteNumberLinkId")) {
      JsonArray array = json.getAsJsonArray("noteNumberLinkId");
      for (int i = 0; i < array.size(); i++) {
        res.getNoteNumberLinkId().add(parsePositiveInt(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_noteNumberLinkId")) {
      JsonArray array = json.getAsJsonArray("_noteNumberLinkId");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getNoteNumberLinkId().size())
          res.getNoteNumberLinkId().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getNoteNumberLinkId().get(i));
      }
    }
    ;
    if (json.has("adjudication")) {
      JsonArray array = json.getAsJsonArray("adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication()
            .add(parseClaimResponseAddedItemAdjudicationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimResponseAddedItemsDetailComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.AddedItemAdjudicationComponent parseClaimResponseAddedItemAdjudicationComponent(
      JsonObject json, ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemAdjudicationComponent res = new ClaimResponse.AddedItemAdjudicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ClaimResponse.AddedItemsDetailComponent parseClaimResponseAddedItemsDetailComponent(JsonObject json,
      ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemsDetailComponent res = new ClaimResponse.AddedItemsDetailComponent();
    parseBackboneProperties(json, res);
    if (json.has("service"))
      res.setService(parseCoding(json.getAsJsonObject("service")));
    if (json.has("fee"))
      res.setFee(parseMoney(json.getAsJsonObject("fee")));
    if (json.has("adjudication")) {
      JsonArray array = json.getAsJsonArray("adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication()
            .add(parseClaimResponseAddedItemDetailAdjudicationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ClaimResponse.AddedItemDetailAdjudicationComponent parseClaimResponseAddedItemDetailAdjudicationComponent(
      JsonObject json, ClaimResponse owner) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemDetailAdjudicationComponent res = new ClaimResponse.AddedItemDetailAdjudicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ClaimResponse.ErrorsComponent parseClaimResponseErrorsComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.ErrorsComponent res = new ClaimResponse.ErrorsComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId"))
      res.setSequenceLinkIdElement(parsePositiveInt(json.get("sequenceLinkId").getAsString()));
    if (json.has("_sequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_sequenceLinkId"), res.getSequenceLinkIdElement());
    if (json.has("detailSequenceLinkId"))
      res.setDetailSequenceLinkIdElement(parsePositiveInt(json.get("detailSequenceLinkId").getAsString()));
    if (json.has("_detailSequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_detailSequenceLinkId"), res.getDetailSequenceLinkIdElement());
    if (json.has("subdetailSequenceLinkId"))
      res.setSubdetailSequenceLinkIdElement(parsePositiveInt(json.get("subdetailSequenceLinkId").getAsString()));
    if (json.has("_subdetailSequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_subdetailSequenceLinkId"), res.getSubdetailSequenceLinkIdElement());
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    return res;
  }

  protected ClaimResponse.NotesComponent parseClaimResponseNotesComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.NotesComponent res = new ClaimResponse.NotesComponent();
    parseBackboneProperties(json, res);
    if (json.has("number"))
      res.setNumberElement(parsePositiveInt(json.get("number").getAsString()));
    if (json.has("_number"))
      parseElementProperties(json.getAsJsonObject("_number"), res.getNumberElement());
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected ClaimResponse.CoverageComponent parseClaimResponseCoverageComponent(JsonObject json, ClaimResponse owner)
      throws IOException, FHIRFormatError {
    ClaimResponse.CoverageComponent res = new ClaimResponse.CoverageComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("focal"))
      res.setFocalElement(parseBoolean(json.get("focal").getAsBoolean()));
    if (json.has("_focal"))
      parseElementProperties(json.getAsJsonObject("_focal"), res.getFocalElement());
    if (json.has("coverage"))
      res.setCoverage(parseReference(json.getAsJsonObject("coverage")));
    if (json.has("businessArrangement"))
      res.setBusinessArrangementElement(parseString(json.get("businessArrangement").getAsString()));
    if (json.has("_businessArrangement"))
      parseElementProperties(json.getAsJsonObject("_businessArrangement"), res.getBusinessArrangementElement());
    if (json.has("relationship"))
      res.setRelationship(parseCoding(json.getAsJsonObject("relationship")));
    if (json.has("preAuthRef")) {
      JsonArray array = json.getAsJsonArray("preAuthRef");
      for (int i = 0; i < array.size(); i++) {
        res.getPreAuthRef().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_preAuthRef")) {
      JsonArray array = json.getAsJsonArray("_preAuthRef");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPreAuthRef().size())
          res.getPreAuthRef().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPreAuthRef().get(i));
      }
    }
    ;
    if (json.has("claimResponse"))
      res.setClaimResponse(parseReference(json.getAsJsonObject("claimResponse")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    return res;
  }

  protected ClinicalImpression parseClinicalImpression(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalImpression res = new ClinicalImpression();
    parseDomainResourceProperties(json, res);
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("assessor"))
      res.setAssessor(parseReference(json.getAsJsonObject("assessor")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), ClinicalImpression.ClinicalImpressionStatus.NULL,
              new ClinicalImpression.ClinicalImpressionStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("previous"))
      res.setPrevious(parseReference(json.getAsJsonObject("previous")));
    if (json.has("problem")) {
      JsonArray array = json.getAsJsonArray("problem");
      for (int i = 0; i < array.size(); i++) {
        res.getProblem().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type trigger = parseType("trigger", json);
    if (trigger != null)
      res.setTrigger(trigger);
    if (json.has("investigations")) {
      JsonArray array = json.getAsJsonArray("investigations");
      for (int i = 0; i < array.size(); i++) {
        res.getInvestigations()
            .add(parseClinicalImpressionClinicalImpressionInvestigationsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("protocol"))
      res.setProtocolElement(parseUri(json.get("protocol").getAsString()));
    if (json.has("_protocol"))
      parseElementProperties(json.getAsJsonObject("_protocol"), res.getProtocolElement());
    if (json.has("summary"))
      res.setSummaryElement(parseString(json.get("summary").getAsString()));
    if (json.has("_summary"))
      parseElementProperties(json.getAsJsonObject("_summary"), res.getSummaryElement());
    if (json.has("finding")) {
      JsonArray array = json.getAsJsonArray("finding");
      for (int i = 0; i < array.size(); i++) {
        res.getFinding()
            .add(parseClinicalImpressionClinicalImpressionFindingComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("resolved")) {
      JsonArray array = json.getAsJsonArray("resolved");
      for (int i = 0; i < array.size(); i++) {
        res.getResolved().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruledOut")) {
      JsonArray array = json.getAsJsonArray("ruledOut");
      for (int i = 0; i < array.size(); i++) {
        res.getRuledOut()
            .add(parseClinicalImpressionClinicalImpressionRuledOutComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("prognosis"))
      res.setPrognosisElement(parseString(json.get("prognosis").getAsString()));
    if (json.has("_prognosis"))
      parseElementProperties(json.getAsJsonObject("_prognosis"), res.getPrognosisElement());
    if (json.has("plan")) {
      JsonArray array = json.getAsJsonArray("plan");
      for (int i = 0; i < array.size(); i++) {
        res.getPlan().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ClinicalImpression.ClinicalImpressionInvestigationsComponent parseClinicalImpressionClinicalImpressionInvestigationsComponent(
      JsonObject json, ClinicalImpression owner) throws IOException, FHIRFormatError {
    ClinicalImpression.ClinicalImpressionInvestigationsComponent res = new ClinicalImpression.ClinicalImpressionInvestigationsComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("item")) {
      JsonArray array = json.getAsJsonArray("item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ClinicalImpression.ClinicalImpressionFindingComponent parseClinicalImpressionClinicalImpressionFindingComponent(
      JsonObject json, ClinicalImpression owner) throws IOException, FHIRFormatError {
    ClinicalImpression.ClinicalImpressionFindingComponent res = new ClinicalImpression.ClinicalImpressionFindingComponent();
    parseBackboneProperties(json, res);
    if (json.has("item"))
      res.setItem(parseCodeableConcept(json.getAsJsonObject("item")));
    if (json.has("cause"))
      res.setCauseElement(parseString(json.get("cause").getAsString()));
    if (json.has("_cause"))
      parseElementProperties(json.getAsJsonObject("_cause"), res.getCauseElement());
    return res;
  }

  protected ClinicalImpression.ClinicalImpressionRuledOutComponent parseClinicalImpressionClinicalImpressionRuledOutComponent(
      JsonObject json, ClinicalImpression owner) throws IOException, FHIRFormatError {
    ClinicalImpression.ClinicalImpressionRuledOutComponent res = new ClinicalImpression.ClinicalImpressionRuledOutComponent();
    parseBackboneProperties(json, res);
    if (json.has("item"))
      res.setItem(parseCodeableConcept(json.getAsJsonObject("item")));
    if (json.has("reason"))
      res.setReasonElement(parseString(json.get("reason").getAsString()));
    if (json.has("_reason"))
      parseElementProperties(json.getAsJsonObject("_reason"), res.getReasonElement());
    return res;
  }

  protected Communication parseCommunication(JsonObject json) throws IOException, FHIRFormatError {
    Communication res = new Communication();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("sender"))
      res.setSender(parseReference(json.getAsJsonObject("sender")));
    if (json.has("recipient")) {
      JsonArray array = json.getAsJsonArray("recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("payload")) {
      JsonArray array = json.getAsJsonArray("payload");
      for (int i = 0; i < array.size(); i++) {
        res.getPayload().add(parseCommunicationCommunicationPayloadComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("medium")) {
      JsonArray array = json.getAsJsonArray("medium");
      for (int i = 0; i < array.size(); i++) {
        res.getMedium().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Communication.CommunicationStatus.NULL,
          new Communication.CommunicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("sent"))
      res.setSentElement(parseDateTime(json.get("sent").getAsString()));
    if (json.has("_sent"))
      parseElementProperties(json.getAsJsonObject("_sent"), res.getSentElement());
    if (json.has("received"))
      res.setReceivedElement(parseDateTime(json.get("received").getAsString()));
    if (json.has("_received"))
      parseElementProperties(json.getAsJsonObject("_received"), res.getReceivedElement());
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("requestDetail"))
      res.setRequestDetail(parseReference(json.getAsJsonObject("requestDetail")));
    return res;
  }

  protected Communication.CommunicationPayloadComponent parseCommunicationCommunicationPayloadComponent(JsonObject json,
      Communication owner) throws IOException, FHIRFormatError {
    Communication.CommunicationPayloadComponent res = new Communication.CommunicationPayloadComponent();
    parseBackboneProperties(json, res);
    Type content = parseType("content", json);
    if (content != null)
      res.setContent(content);
    return res;
  }

  protected CommunicationRequest parseCommunicationRequest(JsonObject json) throws IOException, FHIRFormatError {
    CommunicationRequest res = new CommunicationRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("sender"))
      res.setSender(parseReference(json.getAsJsonObject("sender")));
    if (json.has("recipient")) {
      JsonArray array = json.getAsJsonArray("recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("payload")) {
      JsonArray array = json.getAsJsonArray("payload");
      for (int i = 0; i < array.size(); i++) {
        res.getPayload()
            .add(parseCommunicationRequestCommunicationRequestPayloadComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("medium")) {
      JsonArray array = json.getAsJsonArray("medium");
      for (int i = 0; i < array.size(); i++) {
        res.getMedium().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("requester"))
      res.setRequester(parseReference(json.getAsJsonObject("requester")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), CommunicationRequest.CommunicationRequestStatus.NULL,
              new CommunicationRequest.CommunicationRequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    Type scheduled = parseType("scheduled", json);
    if (scheduled != null)
      res.setScheduled(scheduled);
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("requestedOn"))
      res.setRequestedOnElement(parseDateTime(json.get("requestedOn").getAsString()));
    if (json.has("_requestedOn"))
      parseElementProperties(json.getAsJsonObject("_requestedOn"), res.getRequestedOnElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(json.getAsJsonObject("priority")));
    return res;
  }

  protected CommunicationRequest.CommunicationRequestPayloadComponent parseCommunicationRequestCommunicationRequestPayloadComponent(
      JsonObject json, CommunicationRequest owner) throws IOException, FHIRFormatError {
    CommunicationRequest.CommunicationRequestPayloadComponent res = new CommunicationRequest.CommunicationRequestPayloadComponent();
    parseBackboneProperties(json, res);
    Type content = parseType("content", json);
    if (content != null)
      res.setContent(content);
    return res;
  }

  protected Composition parseComposition(JsonObject json) throws IOException, FHIRFormatError {
    Composition res = new Composition();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("class"))
      res.setClass_(parseCodeableConcept(json.getAsJsonObject("class")));
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Composition.CompositionStatus.NULL,
          new Composition.CompositionStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("confidentiality"))
      res.setConfidentialityElement(parseCode(json.get("confidentiality").getAsString()));
    if (json.has("_confidentiality"))
      parseElementProperties(json.getAsJsonObject("_confidentiality"), res.getConfidentialityElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("author")) {
      JsonArray array = json.getAsJsonArray("author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("attester")) {
      JsonArray array = json.getAsJsonArray("attester");
      for (int i = 0; i < array.size(); i++) {
        res.getAttester().add(parseCompositionCompositionAttesterComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("custodian"))
      res.setCustodian(parseReference(json.getAsJsonObject("custodian")));
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseCompositionCompositionEventComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("section")) {
      JsonArray array = json.getAsJsonArray("section");
      for (int i = 0; i < array.size(); i++) {
        res.getSection().add(parseCompositionSectionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Composition.CompositionAttesterComponent parseCompositionCompositionAttesterComponent(JsonObject json,
      Composition owner) throws IOException, FHIRFormatError {
    Composition.CompositionAttesterComponent res = new Composition.CompositionAttesterComponent();
    parseBackboneProperties(json, res);
    if (json.has("mode")) {
      JsonArray array = json.getAsJsonArray("mode");
      for (int i = 0; i < array.size(); i++) {
        res.getMode().add(parseEnumeration(array.get(i).getAsString(), Composition.CompositionAttestationMode.NULL,
            new Composition.CompositionAttestationModeEnumFactory()));
      }
    }
    ;
    if (json.has("_mode")) {
      JsonArray array = json.getAsJsonArray("_mode");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getMode().size())
          res.getMode().add(parseEnumeration(null, Composition.CompositionAttestationMode.NULL,
              new Composition.CompositionAttestationModeEnumFactory()));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getMode().get(i));
      }
    }
    ;
    if (json.has("time"))
      res.setTimeElement(parseDateTime(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(json.getAsJsonObject("_time"), res.getTimeElement());
    if (json.has("party"))
      res.setParty(parseReference(json.getAsJsonObject("party")));
    return res;
  }

  protected Composition.CompositionEventComponent parseCompositionCompositionEventComponent(JsonObject json,
      Composition owner) throws IOException, FHIRFormatError {
    Composition.CompositionEventComponent res = new Composition.CompositionEventComponent();
    parseBackboneProperties(json, res);
    if (json.has("code")) {
      JsonArray array = json.getAsJsonArray("code");
      for (int i = 0; i < array.size(); i++) {
        res.getCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Composition.SectionComponent parseCompositionSectionComponent(JsonObject json, Composition owner)
      throws IOException, FHIRFormatError {
    Composition.SectionComponent res = new Composition.SectionComponent();
    parseBackboneProperties(json, res);
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("text"))
      res.setText(parseNarrative(json.getAsJsonObject("text")));
    if (json.has("mode"))
      res.setModeElement(parseCode(json.get("mode").getAsString()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("orderedBy"))
      res.setOrderedBy(parseCodeableConcept(json.getAsJsonObject("orderedBy")));
    if (json.has("entry")) {
      JsonArray array = json.getAsJsonArray("entry");
      for (int i = 0; i < array.size(); i++) {
        res.getEntry().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("emptyReason"))
      res.setEmptyReason(parseCodeableConcept(json.getAsJsonObject("emptyReason")));
    if (json.has("section")) {
      JsonArray array = json.getAsJsonArray("section");
      for (int i = 0; i < array.size(); i++) {
        res.getSection().add(parseCompositionSectionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ConceptMap parseConceptMap(JsonObject json) throws IOException, FHIRFormatError {
    ConceptMap res = new ConceptMap();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseConceptMapConceptMapContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    Type source = parseType("source", json);
    if (source != null)
      res.setSource(source);
    Type target = parseType("target", json);
    if (target != null)
      res.setTarget(target);
    if (json.has("element")) {
      JsonArray array = json.getAsJsonArray("element");
      for (int i = 0; i < array.size(); i++) {
        res.getElement().add(parseConceptMapSourceElementComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ConceptMap.ConceptMapContactComponent parseConceptMapConceptMapContactComponent(JsonObject json,
      ConceptMap owner) throws IOException, FHIRFormatError {
    ConceptMap.ConceptMapContactComponent res = new ConceptMap.ConceptMapContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ConceptMap.SourceElementComponent parseConceptMapSourceElementComponent(JsonObject json, ConceptMap owner)
      throws IOException, FHIRFormatError {
    ConceptMap.SourceElementComponent res = new ConceptMap.SourceElementComponent();
    parseBackboneProperties(json, res);
    if (json.has("codeSystem"))
      res.setCodeSystemElement(parseUri(json.get("codeSystem").getAsString()));
    if (json.has("_codeSystem"))
      parseElementProperties(json.getAsJsonObject("_codeSystem"), res.getCodeSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("target")) {
      JsonArray array = json.getAsJsonArray("target");
      for (int i = 0; i < array.size(); i++) {
        res.getTarget().add(parseConceptMapTargetElementComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ConceptMap.TargetElementComponent parseConceptMapTargetElementComponent(JsonObject json, ConceptMap owner)
      throws IOException, FHIRFormatError {
    ConceptMap.TargetElementComponent res = new ConceptMap.TargetElementComponent();
    parseBackboneProperties(json, res);
    if (json.has("codeSystem"))
      res.setCodeSystemElement(parseUri(json.get("codeSystem").getAsString()));
    if (json.has("_codeSystem"))
      parseElementProperties(json.getAsJsonObject("_codeSystem"), res.getCodeSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("equivalence"))
      res.setEquivalenceElement(parseEnumeration(json.get("equivalence").getAsString(),
          Enumerations.ConceptMapEquivalence.NULL, new Enumerations.ConceptMapEquivalenceEnumFactory()));
    if (json.has("_equivalence"))
      parseElementProperties(json.getAsJsonObject("_equivalence"), res.getEquivalenceElement());
    if (json.has("comments"))
      res.setCommentsElement(parseString(json.get("comments").getAsString()));
    if (json.has("_comments"))
      parseElementProperties(json.getAsJsonObject("_comments"), res.getCommentsElement());
    if (json.has("dependsOn")) {
      JsonArray array = json.getAsJsonArray("dependsOn");
      for (int i = 0; i < array.size(); i++) {
        res.getDependsOn().add(parseConceptMapOtherElementComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("product")) {
      JsonArray array = json.getAsJsonArray("product");
      for (int i = 0; i < array.size(); i++) {
        res.getProduct().add(parseConceptMapOtherElementComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ConceptMap.OtherElementComponent parseConceptMapOtherElementComponent(JsonObject json, ConceptMap owner)
      throws IOException, FHIRFormatError {
    ConceptMap.OtherElementComponent res = new ConceptMap.OtherElementComponent();
    parseBackboneProperties(json, res);
    if (json.has("element"))
      res.setElementElement(parseUri(json.get("element").getAsString()));
    if (json.has("_element"))
      parseElementProperties(json.getAsJsonObject("_element"), res.getElementElement());
    if (json.has("codeSystem"))
      res.setCodeSystemElement(parseUri(json.get("codeSystem").getAsString()));
    if (json.has("_codeSystem"))
      parseElementProperties(json.getAsJsonObject("_codeSystem"), res.getCodeSystemElement());
    if (json.has("code"))
      res.setCodeElement(parseString(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    return res;
  }

  protected Condition parseCondition(JsonObject json) throws IOException, FHIRFormatError {
    Condition res = new Condition();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("asserter"))
      res.setAsserter(parseReference(json.getAsJsonObject("asserter")));
    if (json.has("dateRecorded"))
      res.setDateRecordedElement(parseDate(json.get("dateRecorded").getAsString()));
    if (json.has("_dateRecorded"))
      parseElementProperties(json.getAsJsonObject("_dateRecorded"), res.getDateRecordedElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("clinicalStatus"))
      res.setClinicalStatusElement(parseCode(json.get("clinicalStatus").getAsString()));
    if (json.has("_clinicalStatus"))
      parseElementProperties(json.getAsJsonObject("_clinicalStatus"), res.getClinicalStatusElement());
    if (json.has("verificationStatus"))
      res.setVerificationStatusElement(parseEnumeration(json.get("verificationStatus").getAsString(),
          Condition.ConditionVerificationStatus.NULL, new Condition.ConditionVerificationStatusEnumFactory()));
    if (json.has("_verificationStatus"))
      parseElementProperties(json.getAsJsonObject("_verificationStatus"), res.getVerificationStatusElement());
    if (json.has("severity"))
      res.setSeverity(parseCodeableConcept(json.getAsJsonObject("severity")));
    Type onset = parseType("onset", json);
    if (onset != null)
      res.setOnset(onset);
    Type abatement = parseType("abatement", json);
    if (abatement != null)
      res.setAbatement(abatement);
    if (json.has("stage"))
      res.setStage(parseConditionConditionStageComponent(json.getAsJsonObject("stage"), res));
    if (json.has("evidence")) {
      JsonArray array = json.getAsJsonArray("evidence");
      for (int i = 0; i < array.size(); i++) {
        res.getEvidence().add(parseConditionConditionEvidenceComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("bodySite")) {
      JsonArray array = json.getAsJsonArray("bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("notes"))
      res.setNotesElement(parseString(json.get("notes").getAsString()));
    if (json.has("_notes"))
      parseElementProperties(json.getAsJsonObject("_notes"), res.getNotesElement());
    return res;
  }

  protected Condition.ConditionStageComponent parseConditionConditionStageComponent(JsonObject json, Condition owner)
      throws IOException, FHIRFormatError {
    Condition.ConditionStageComponent res = new Condition.ConditionStageComponent();
    parseBackboneProperties(json, res);
    if (json.has("summary"))
      res.setSummary(parseCodeableConcept(json.getAsJsonObject("summary")));
    if (json.has("assessment")) {
      JsonArray array = json.getAsJsonArray("assessment");
      for (int i = 0; i < array.size(); i++) {
        res.getAssessment().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Condition.ConditionEvidenceComponent parseConditionConditionEvidenceComponent(JsonObject json,
      Condition owner) throws IOException, FHIRFormatError {
    Condition.ConditionEvidenceComponent res = new Condition.ConditionEvidenceComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Conformance parseConformance(JsonObject json) throws IOException, FHIRFormatError {
    Conformance res = new Conformance();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseConformanceConformanceContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), Conformance.ConformanceStatementKind.NULL,
          new Conformance.ConformanceStatementKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(json.getAsJsonObject("_kind"), res.getKindElement());
    if (json.has("software"))
      res.setSoftware(parseConformanceConformanceSoftwareComponent(json.getAsJsonObject("software"), res));
    if (json.has("implementation"))
      res.setImplementation(
          parseConformanceConformanceImplementationComponent(json.getAsJsonObject("implementation"), res));
    if (json.has("fhirVersion"))
      res.setFhirVersionElement(parseId(json.get("fhirVersion").getAsString()));
    if (json.has("_fhirVersion"))
      parseElementProperties(json.getAsJsonObject("_fhirVersion"), res.getFhirVersionElement());
    if (json.has("acceptUnknown"))
      res.setAcceptUnknownElement(parseEnumeration(json.get("acceptUnknown").getAsString(),
          Conformance.UnknownContentCode.NULL, new Conformance.UnknownContentCodeEnumFactory()));
    if (json.has("_acceptUnknown"))
      parseElementProperties(json.getAsJsonObject("_acceptUnknown"), res.getAcceptUnknownElement());
    if (json.has("format")) {
      JsonArray array = json.getAsJsonArray("format");
      for (int i = 0; i < array.size(); i++) {
        res.getFormat().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_format")) {
      JsonArray array = json.getAsJsonArray("_format");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getFormat().size())
          res.getFormat().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getFormat().get(i));
      }
    }
    ;
    if (json.has("profile")) {
      JsonArray array = json.getAsJsonArray("profile");
      for (int i = 0; i < array.size(); i++) {
        res.getProfile().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("rest")) {
      JsonArray array = json.getAsJsonArray("rest");
      for (int i = 0; i < array.size(); i++) {
        res.getRest().add(parseConformanceConformanceRestComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("messaging")) {
      JsonArray array = json.getAsJsonArray("messaging");
      for (int i = 0; i < array.size(); i++) {
        res.getMessaging().add(parseConformanceConformanceMessagingComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("document")) {
      JsonArray array = json.getAsJsonArray("document");
      for (int i = 0; i < array.size(); i++) {
        res.getDocument().add(parseConformanceConformanceDocumentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Conformance.ConformanceContactComponent parseConformanceConformanceContactComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceContactComponent res = new Conformance.ConformanceContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Conformance.ConformanceSoftwareComponent parseConformanceConformanceSoftwareComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceSoftwareComponent res = new Conformance.ConformanceSoftwareComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("releaseDate"))
      res.setReleaseDateElement(parseDateTime(json.get("releaseDate").getAsString()));
    if (json.has("_releaseDate"))
      parseElementProperties(json.getAsJsonObject("_releaseDate"), res.getReleaseDateElement());
    return res;
  }

  protected Conformance.ConformanceImplementationComponent parseConformanceConformanceImplementationComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceImplementationComponent res = new Conformance.ConformanceImplementationComponent();
    parseBackboneProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    return res;
  }

  protected Conformance.ConformanceRestComponent parseConformanceConformanceRestComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestComponent res = new Conformance.ConformanceRestComponent();
    parseBackboneProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Conformance.RestfulConformanceMode.NULL,
          new Conformance.RestfulConformanceModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    if (json.has("security"))
      res.setSecurity(parseConformanceConformanceRestSecurityComponent(json.getAsJsonObject("security"), owner));
    if (json.has("resource")) {
      JsonArray array = json.getAsJsonArray("resource");
      for (int i = 0; i < array.size(); i++) {
        res.getResource().add(parseConformanceConformanceRestResourceComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("interaction")) {
      JsonArray array = json.getAsJsonArray("interaction");
      for (int i = 0; i < array.size(); i++) {
        res.getInteraction().add(parseConformanceSystemInteractionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("transactionMode"))
      res.setTransactionModeElement(parseEnumeration(json.get("transactionMode").getAsString(),
          Conformance.TransactionMode.NULL, new Conformance.TransactionModeEnumFactory()));
    if (json.has("_transactionMode"))
      parseElementProperties(json.getAsJsonObject("_transactionMode"), res.getTransactionModeElement());
    if (json.has("searchParam")) {
      JsonArray array = json.getAsJsonArray("searchParam");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchParam()
            .add(parseConformanceConformanceRestResourceSearchParamComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("operation")) {
      JsonArray array = json.getAsJsonArray("operation");
      for (int i = 0; i < array.size(); i++) {
        res.getOperation()
            .add(parseConformanceConformanceRestOperationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("compartment")) {
      JsonArray array = json.getAsJsonArray("compartment");
      for (int i = 0; i < array.size(); i++) {
        res.getCompartment().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_compartment")) {
      JsonArray array = json.getAsJsonArray("_compartment");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getCompartment().size())
          res.getCompartment().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getCompartment().get(i));
      }
    }
    ;
    return res;
  }

  protected Conformance.ConformanceRestSecurityComponent parseConformanceConformanceRestSecurityComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestSecurityComponent res = new Conformance.ConformanceRestSecurityComponent();
    parseBackboneProperties(json, res);
    if (json.has("cors"))
      res.setCorsElement(parseBoolean(json.get("cors").getAsBoolean()));
    if (json.has("_cors"))
      parseElementProperties(json.getAsJsonObject("_cors"), res.getCorsElement());
    if (json.has("service")) {
      JsonArray array = json.getAsJsonArray("service");
      for (int i = 0; i < array.size(); i++) {
        res.getService().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("certificate")) {
      JsonArray array = json.getAsJsonArray("certificate");
      for (int i = 0; i < array.size(); i++) {
        res.getCertificate()
            .add(parseConformanceConformanceRestSecurityCertificateComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Conformance.ConformanceRestSecurityCertificateComponent parseConformanceConformanceRestSecurityCertificateComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestSecurityCertificateComponent res = new Conformance.ConformanceRestSecurityCertificateComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseCode(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("blob"))
      res.setBlobElement(parseBase64Binary(json.get("blob").getAsString()));
    if (json.has("_blob"))
      parseElementProperties(json.getAsJsonObject("_blob"), res.getBlobElement());
    return res;
  }

  protected Conformance.ConformanceRestResourceComponent parseConformanceConformanceRestResourceComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestResourceComponent res = new Conformance.ConformanceRestResourceComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseCode(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("profile"))
      res.setProfile(parseReference(json.getAsJsonObject("profile")));
    if (json.has("interaction")) {
      JsonArray array = json.getAsJsonArray("interaction");
      for (int i = 0; i < array.size(); i++) {
        res.getInteraction().add(parseConformanceResourceInteractionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("versioning"))
      res.setVersioningElement(parseEnumeration(json.get("versioning").getAsString(),
          Conformance.ResourceVersionPolicy.NULL, new Conformance.ResourceVersionPolicyEnumFactory()));
    if (json.has("_versioning"))
      parseElementProperties(json.getAsJsonObject("_versioning"), res.getVersioningElement());
    if (json.has("readHistory"))
      res.setReadHistoryElement(parseBoolean(json.get("readHistory").getAsBoolean()));
    if (json.has("_readHistory"))
      parseElementProperties(json.getAsJsonObject("_readHistory"), res.getReadHistoryElement());
    if (json.has("updateCreate"))
      res.setUpdateCreateElement(parseBoolean(json.get("updateCreate").getAsBoolean()));
    if (json.has("_updateCreate"))
      parseElementProperties(json.getAsJsonObject("_updateCreate"), res.getUpdateCreateElement());
    if (json.has("conditionalCreate"))
      res.setConditionalCreateElement(parseBoolean(json.get("conditionalCreate").getAsBoolean()));
    if (json.has("_conditionalCreate"))
      parseElementProperties(json.getAsJsonObject("_conditionalCreate"), res.getConditionalCreateElement());
    if (json.has("conditionalUpdate"))
      res.setConditionalUpdateElement(parseBoolean(json.get("conditionalUpdate").getAsBoolean()));
    if (json.has("_conditionalUpdate"))
      parseElementProperties(json.getAsJsonObject("_conditionalUpdate"), res.getConditionalUpdateElement());
    if (json.has("conditionalDelete"))
      res.setConditionalDeleteElement(parseEnumeration(json.get("conditionalDelete").getAsString(),
          Conformance.ConditionalDeleteStatus.NULL, new Conformance.ConditionalDeleteStatusEnumFactory()));
    if (json.has("_conditionalDelete"))
      parseElementProperties(json.getAsJsonObject("_conditionalDelete"), res.getConditionalDeleteElement());
    if (json.has("searchInclude")) {
      JsonArray array = json.getAsJsonArray("searchInclude");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchInclude().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_searchInclude")) {
      JsonArray array = json.getAsJsonArray("_searchInclude");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSearchInclude().size())
          res.getSearchInclude().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSearchInclude().get(i));
      }
    }
    ;
    if (json.has("searchRevInclude")) {
      JsonArray array = json.getAsJsonArray("searchRevInclude");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchRevInclude().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_searchRevInclude")) {
      JsonArray array = json.getAsJsonArray("_searchRevInclude");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSearchRevInclude().size())
          res.getSearchRevInclude().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSearchRevInclude().get(i));
      }
    }
    ;
    if (json.has("searchParam")) {
      JsonArray array = json.getAsJsonArray("searchParam");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchParam()
            .add(parseConformanceConformanceRestResourceSearchParamComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Conformance.ResourceInteractionComponent parseConformanceResourceInteractionComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ResourceInteractionComponent res = new Conformance.ResourceInteractionComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), Conformance.TypeRestfulInteraction.NULL,
          new Conformance.TypeRestfulInteractionEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    return res;
  }

  protected Conformance.ConformanceRestResourceSearchParamComponent parseConformanceConformanceRestResourceSearchParamComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestResourceSearchParamComponent res = new Conformance.ConformanceRestResourceSearchParamComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseUri(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(json.getAsJsonObject("_definition"), res.getDefinitionElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.SearchParamType.NULL,
          new Enumerations.SearchParamTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    if (json.has("target")) {
      JsonArray array = json.getAsJsonArray("target");
      for (int i = 0; i < array.size(); i++) {
        res.getTarget().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_target")) {
      JsonArray array = json.getAsJsonArray("_target");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getTarget().size())
          res.getTarget().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getTarget().get(i));
      }
    }
    ;
    if (json.has("modifier")) {
      JsonArray array = json.getAsJsonArray("modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseEnumeration(array.get(i).getAsString(), Conformance.SearchModifierCode.NULL,
            new Conformance.SearchModifierCodeEnumFactory()));
      }
    }
    ;
    if (json.has("_modifier")) {
      JsonArray array = json.getAsJsonArray("_modifier");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getModifier().size())
          res.getModifier().add(parseEnumeration(null, Conformance.SearchModifierCode.NULL,
              new Conformance.SearchModifierCodeEnumFactory()));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getModifier().get(i));
      }
    }
    ;
    if (json.has("chain")) {
      JsonArray array = json.getAsJsonArray("chain");
      for (int i = 0; i < array.size(); i++) {
        res.getChain().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_chain")) {
      JsonArray array = json.getAsJsonArray("_chain");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getChain().size())
          res.getChain().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getChain().get(i));
      }
    }
    ;
    return res;
  }

  protected Conformance.SystemInteractionComponent parseConformanceSystemInteractionComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.SystemInteractionComponent res = new Conformance.SystemInteractionComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), Conformance.SystemRestfulInteraction.NULL,
          new Conformance.SystemRestfulInteractionEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    return res;
  }

  protected Conformance.ConformanceRestOperationComponent parseConformanceConformanceRestOperationComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceRestOperationComponent res = new Conformance.ConformanceRestOperationComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("definition"))
      res.setDefinition(parseReference(json.getAsJsonObject("definition")));
    return res;
  }

  protected Conformance.ConformanceMessagingComponent parseConformanceConformanceMessagingComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceMessagingComponent res = new Conformance.ConformanceMessagingComponent();
    parseBackboneProperties(json, res);
    if (json.has("endpoint")) {
      JsonArray array = json.getAsJsonArray("endpoint");
      for (int i = 0; i < array.size(); i++) {
        res.getEndpoint()
            .add(parseConformanceConformanceMessagingEndpointComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("reliableCache"))
      res.setReliableCacheElement(parseUnsignedInt(json.get("reliableCache").getAsString()));
    if (json.has("_reliableCache"))
      parseElementProperties(json.getAsJsonObject("_reliableCache"), res.getReliableCacheElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseConformanceConformanceMessagingEventComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Conformance.ConformanceMessagingEndpointComponent parseConformanceConformanceMessagingEndpointComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceMessagingEndpointComponent res = new Conformance.ConformanceMessagingEndpointComponent();
    parseBackboneProperties(json, res);
    if (json.has("protocol"))
      res.setProtocol(parseCoding(json.getAsJsonObject("protocol")));
    if (json.has("address"))
      res.setAddressElement(parseUri(json.get("address").getAsString()));
    if (json.has("_address"))
      parseElementProperties(json.getAsJsonObject("_address"), res.getAddressElement());
    return res;
  }

  protected Conformance.ConformanceMessagingEventComponent parseConformanceConformanceMessagingEventComponent(
      JsonObject json, Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceMessagingEventComponent res = new Conformance.ConformanceMessagingEventComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(json.getAsJsonObject("code")));
    if (json.has("category"))
      res.setCategoryElement(parseEnumeration(json.get("category").getAsString(),
          Conformance.MessageSignificanceCategory.NULL, new Conformance.MessageSignificanceCategoryEnumFactory()));
    if (json.has("_category"))
      parseElementProperties(json.getAsJsonObject("_category"), res.getCategoryElement());
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Conformance.ConformanceEventMode.NULL,
          new Conformance.ConformanceEventModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("focus"))
      res.setFocusElement(parseCode(json.get("focus").getAsString()));
    if (json.has("_focus"))
      parseElementProperties(json.getAsJsonObject("_focus"), res.getFocusElement());
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("response"))
      res.setResponse(parseReference(json.getAsJsonObject("response")));
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    return res;
  }

  protected Conformance.ConformanceDocumentComponent parseConformanceConformanceDocumentComponent(JsonObject json,
      Conformance owner) throws IOException, FHIRFormatError {
    Conformance.ConformanceDocumentComponent res = new Conformance.ConformanceDocumentComponent();
    parseBackboneProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Conformance.DocumentMode.NULL,
          new Conformance.DocumentModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    if (json.has("profile"))
      res.setProfile(parseReference(json.getAsJsonObject("profile")));
    return res;
  }

  protected Contract parseContract(JsonObject json) throws IOException, FHIRFormatError {
    Contract res = new Contract();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("issued"))
      res.setIssuedElement(parseDateTime(json.get("issued").getAsString()));
    if (json.has("_issued"))
      parseElementProperties(json.getAsJsonObject("_issued"), res.getIssuedElement());
    if (json.has("applies"))
      res.setApplies(parsePeriod(json.getAsJsonObject("applies")));
    if (json.has("subject")) {
      JsonArray array = json.getAsJsonArray("subject");
      for (int i = 0; i < array.size(); i++) {
        res.getSubject().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("authority")) {
      JsonArray array = json.getAsJsonArray("authority");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthority().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("domain")) {
      JsonArray array = json.getAsJsonArray("domain");
      for (int i = 0; i < array.size(); i++) {
        res.getDomain().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("subType")) {
      JsonArray array = json.getAsJsonArray("subType");
      for (int i = 0; i < array.size(); i++) {
        res.getSubType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actionReason")) {
      JsonArray array = json.getAsJsonArray("actionReason");
      for (int i = 0; i < array.size(); i++) {
        res.getActionReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actor")) {
      JsonArray array = json.getAsJsonArray("actor");
      for (int i = 0; i < array.size(); i++) {
        res.getActor().add(parseContractActorComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("valuedItem")) {
      JsonArray array = json.getAsJsonArray("valuedItem");
      for (int i = 0; i < array.size(); i++) {
        res.getValuedItem().add(parseContractValuedItemComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("signer")) {
      JsonArray array = json.getAsJsonArray("signer");
      for (int i = 0; i < array.size(); i++) {
        res.getSigner().add(parseContractSignatoryComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("term")) {
      JsonArray array = json.getAsJsonArray("term");
      for (int i = 0; i < array.size(); i++) {
        res.getTerm().add(parseContractTermComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    Type binding = parseType("binding", json);
    if (binding != null)
      res.setBinding(binding);
    if (json.has("friendly")) {
      JsonArray array = json.getAsJsonArray("friendly");
      for (int i = 0; i < array.size(); i++) {
        res.getFriendly().add(parseContractFriendlyLanguageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("legal")) {
      JsonArray array = json.getAsJsonArray("legal");
      for (int i = 0; i < array.size(); i++) {
        res.getLegal().add(parseContractLegalLanguageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("rule")) {
      JsonArray array = json.getAsJsonArray("rule");
      for (int i = 0; i < array.size(); i++) {
        res.getRule().add(parseContractComputableLanguageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Contract.ActorComponent parseContractActorComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.ActorComponent res = new Contract.ActorComponent();
    parseBackboneProperties(json, res);
    if (json.has("entity"))
      res.setEntity(parseReference(json.getAsJsonObject("entity")));
    if (json.has("role")) {
      JsonArray array = json.getAsJsonArray("role");
      for (int i = 0; i < array.size(); i++) {
        res.getRole().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Contract.ValuedItemComponent parseContractValuedItemComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.ValuedItemComponent res = new Contract.ValuedItemComponent();
    parseBackboneProperties(json, res);
    Type entity = parseType("entity", json);
    if (entity != null)
      res.setEntity(entity);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("effectiveTime"))
      res.setEffectiveTimeElement(parseDateTime(json.get("effectiveTime").getAsString()));
    if (json.has("_effectiveTime"))
      parseElementProperties(json.getAsJsonObject("_effectiveTime"), res.getEffectiveTimeElement());
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(json.getAsJsonObject("unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("points"))
      res.setPointsElement(parseDecimal(json.get("points").getAsBigDecimal()));
    if (json.has("_points"))
      parseElementProperties(json.getAsJsonObject("_points"), res.getPointsElement());
    if (json.has("net"))
      res.setNet(parseMoney(json.getAsJsonObject("net")));
    return res;
  }

  protected Contract.SignatoryComponent parseContractSignatoryComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.SignatoryComponent res = new Contract.SignatoryComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("party"))
      res.setParty(parseReference(json.getAsJsonObject("party")));
    if (json.has("signature"))
      res.setSignatureElement(parseString(json.get("signature").getAsString()));
    if (json.has("_signature"))
      parseElementProperties(json.getAsJsonObject("_signature"), res.getSignatureElement());
    return res;
  }

  protected Contract.TermComponent parseContractTermComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.TermComponent res = new Contract.TermComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("issued"))
      res.setIssuedElement(parseDateTime(json.get("issued").getAsString()));
    if (json.has("_issued"))
      parseElementProperties(json.getAsJsonObject("_issued"), res.getIssuedElement());
    if (json.has("applies"))
      res.setApplies(parsePeriod(json.getAsJsonObject("applies")));
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("subType"))
      res.setSubType(parseCodeableConcept(json.getAsJsonObject("subType")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actionReason")) {
      JsonArray array = json.getAsJsonArray("actionReason");
      for (int i = 0; i < array.size(); i++) {
        res.getActionReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actor")) {
      JsonArray array = json.getAsJsonArray("actor");
      for (int i = 0; i < array.size(); i++) {
        res.getActor().add(parseContractTermActorComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("valuedItem")) {
      JsonArray array = json.getAsJsonArray("valuedItem");
      for (int i = 0; i < array.size(); i++) {
        res.getValuedItem().add(parseContractTermValuedItemComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("group")) {
      JsonArray array = json.getAsJsonArray("group");
      for (int i = 0; i < array.size(); i++) {
        res.getGroup().add(parseContractTermComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Contract.TermActorComponent parseContractTermActorComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.TermActorComponent res = new Contract.TermActorComponent();
    parseBackboneProperties(json, res);
    if (json.has("entity"))
      res.setEntity(parseReference(json.getAsJsonObject("entity")));
    if (json.has("role")) {
      JsonArray array = json.getAsJsonArray("role");
      for (int i = 0; i < array.size(); i++) {
        res.getRole().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Contract.TermValuedItemComponent parseContractTermValuedItemComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.TermValuedItemComponent res = new Contract.TermValuedItemComponent();
    parseBackboneProperties(json, res);
    Type entity = parseType("entity", json);
    if (entity != null)
      res.setEntity(entity);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("effectiveTime"))
      res.setEffectiveTimeElement(parseDateTime(json.get("effectiveTime").getAsString()));
    if (json.has("_effectiveTime"))
      parseElementProperties(json.getAsJsonObject("_effectiveTime"), res.getEffectiveTimeElement());
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(json.getAsJsonObject("unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(json.getAsJsonObject("_factor"), res.getFactorElement());
    if (json.has("points"))
      res.setPointsElement(parseDecimal(json.get("points").getAsBigDecimal()));
    if (json.has("_points"))
      parseElementProperties(json.getAsJsonObject("_points"), res.getPointsElement());
    if (json.has("net"))
      res.setNet(parseMoney(json.getAsJsonObject("net")));
    return res;
  }

  protected Contract.FriendlyLanguageComponent parseContractFriendlyLanguageComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.FriendlyLanguageComponent res = new Contract.FriendlyLanguageComponent();
    parseBackboneProperties(json, res);
    Type content = parseType("content", json);
    if (content != null)
      res.setContent(content);
    return res;
  }

  protected Contract.LegalLanguageComponent parseContractLegalLanguageComponent(JsonObject json, Contract owner)
      throws IOException, FHIRFormatError {
    Contract.LegalLanguageComponent res = new Contract.LegalLanguageComponent();
    parseBackboneProperties(json, res);
    Type content = parseType("content", json);
    if (content != null)
      res.setContent(content);
    return res;
  }

  protected Contract.ComputableLanguageComponent parseContractComputableLanguageComponent(JsonObject json,
      Contract owner) throws IOException, FHIRFormatError {
    Contract.ComputableLanguageComponent res = new Contract.ComputableLanguageComponent();
    parseBackboneProperties(json, res);
    Type content = parseType("content", json);
    if (content != null)
      res.setContent(content);
    return res;
  }

  protected Coverage parseCoverage(JsonObject json) throws IOException, FHIRFormatError {
    Coverage res = new Coverage();
    parseDomainResourceProperties(json, res);
    if (json.has("issuer"))
      res.setIssuer(parseReference(json.getAsJsonObject("issuer")));
    if (json.has("bin"))
      res.setBin(parseIdentifier(json.getAsJsonObject("bin")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("subscriberId"))
      res.setSubscriberId(parseIdentifier(json.getAsJsonObject("subscriberId")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("group"))
      res.setGroupElement(parseString(json.get("group").getAsString()));
    if (json.has("_group"))
      parseElementProperties(json.getAsJsonObject("_group"), res.getGroupElement());
    if (json.has("plan"))
      res.setPlanElement(parseString(json.get("plan").getAsString()));
    if (json.has("_plan"))
      parseElementProperties(json.getAsJsonObject("_plan"), res.getPlanElement());
    if (json.has("subPlan"))
      res.setSubPlanElement(parseString(json.get("subPlan").getAsString()));
    if (json.has("_subPlan"))
      parseElementProperties(json.getAsJsonObject("_subPlan"), res.getSubPlanElement());
    if (json.has("dependent"))
      res.setDependentElement(parsePositiveInt(json.get("dependent").getAsString()));
    if (json.has("_dependent"))
      parseElementProperties(json.getAsJsonObject("_dependent"), res.getDependentElement());
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(json.getAsJsonObject("_sequence"), res.getSequenceElement());
    if (json.has("subscriber"))
      res.setSubscriber(parseReference(json.getAsJsonObject("subscriber")));
    if (json.has("network"))
      res.setNetwork(parseIdentifier(json.getAsJsonObject("network")));
    if (json.has("contract")) {
      JsonArray array = json.getAsJsonArray("contract");
      for (int i = 0; i < array.size(); i++) {
        res.getContract().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DataElement parseDataElement(JsonObject json) throws IOException, FHIRFormatError {
    DataElement res = new DataElement();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseDataElementDataElementContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("stringency"))
      res.setStringencyElement(parseEnumeration(json.get("stringency").getAsString(),
          DataElement.DataElementStringency.NULL, new DataElement.DataElementStringencyEnumFactory()));
    if (json.has("_stringency"))
      parseElementProperties(json.getAsJsonObject("_stringency"), res.getStringencyElement());
    if (json.has("mapping")) {
      JsonArray array = json.getAsJsonArray("mapping");
      for (int i = 0; i < array.size(); i++) {
        res.getMapping().add(parseDataElementDataElementMappingComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("element")) {
      JsonArray array = json.getAsJsonArray("element");
      for (int i = 0; i < array.size(); i++) {
        res.getElement().add(parseElementDefinition(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DataElement.DataElementContactComponent parseDataElementDataElementContactComponent(JsonObject json,
      DataElement owner) throws IOException, FHIRFormatError {
    DataElement.DataElementContactComponent res = new DataElement.DataElementContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DataElement.DataElementMappingComponent parseDataElementDataElementMappingComponent(JsonObject json,
      DataElement owner) throws IOException, FHIRFormatError {
    DataElement.DataElementMappingComponent res = new DataElement.DataElementMappingComponent();
    parseBackboneProperties(json, res);
    if (json.has("identity"))
      res.setIdentityElement(parseId(json.get("identity").getAsString()));
    if (json.has("_identity"))
      parseElementProperties(json.getAsJsonObject("_identity"), res.getIdentityElement());
    if (json.has("uri"))
      res.setUriElement(parseUri(json.get("uri").getAsString()));
    if (json.has("_uri"))
      parseElementProperties(json.getAsJsonObject("_uri"), res.getUriElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("comments"))
      res.setCommentsElement(parseString(json.get("comments").getAsString()));
    if (json.has("_comments"))
      parseElementProperties(json.getAsJsonObject("_comments"), res.getCommentsElement());
    return res;
  }

  protected DetectedIssue parseDetectedIssue(JsonObject json) throws IOException, FHIRFormatError {
    DetectedIssue res = new DetectedIssue();
    parseDomainResourceProperties(json, res);
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("severity"))
      res.setSeverityElement(parseEnumeration(json.get("severity").getAsString(),
          DetectedIssue.DetectedIssueSeverity.NULL, new DetectedIssue.DetectedIssueSeverityEnumFactory()));
    if (json.has("_severity"))
      parseElementProperties(json.getAsJsonObject("_severity"), res.getSeverityElement());
    if (json.has("implicated")) {
      JsonArray array = json.getAsJsonArray("implicated");
      for (int i = 0; i < array.size(); i++) {
        res.getImplicated().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("detail"))
      res.setDetailElement(parseString(json.get("detail").getAsString()));
    if (json.has("_detail"))
      parseElementProperties(json.getAsJsonObject("_detail"), res.getDetailElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("reference"))
      res.setReferenceElement(parseUri(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(json.getAsJsonObject("_reference"), res.getReferenceElement());
    if (json.has("mitigation")) {
      JsonArray array = json.getAsJsonArray("mitigation");
      for (int i = 0; i < array.size(); i++) {
        res.getMitigation()
            .add(parseDetectedIssueDetectedIssueMitigationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected DetectedIssue.DetectedIssueMitigationComponent parseDetectedIssueDetectedIssueMitigationComponent(
      JsonObject json, DetectedIssue owner) throws IOException, FHIRFormatError {
    DetectedIssue.DetectedIssueMitigationComponent res = new DetectedIssue.DetectedIssueMitigationComponent();
    parseBackboneProperties(json, res);
    if (json.has("action"))
      res.setAction(parseCodeableConcept(json.getAsJsonObject("action")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    return res;
  }

  protected Device parseDevice(JsonObject json) throws IOException, FHIRFormatError {
    Device res = new Device();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Device.DeviceStatus.NULL,
          new Device.DeviceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("manufacturer"))
      res.setManufacturerElement(parseString(json.get("manufacturer").getAsString()));
    if (json.has("_manufacturer"))
      parseElementProperties(json.getAsJsonObject("_manufacturer"), res.getManufacturerElement());
    if (json.has("model"))
      res.setModelElement(parseString(json.get("model").getAsString()));
    if (json.has("_model"))
      parseElementProperties(json.getAsJsonObject("_model"), res.getModelElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("manufactureDate"))
      res.setManufactureDateElement(parseDateTime(json.get("manufactureDate").getAsString()));
    if (json.has("_manufactureDate"))
      parseElementProperties(json.getAsJsonObject("_manufactureDate"), res.getManufactureDateElement());
    if (json.has("expiry"))
      res.setExpiryElement(parseDateTime(json.get("expiry").getAsString()));
    if (json.has("_expiry"))
      parseElementProperties(json.getAsJsonObject("_expiry"), res.getExpiryElement());
    if (json.has("udi"))
      res.setUdiElement(parseString(json.get("udi").getAsString()));
    if (json.has("_udi"))
      parseElementProperties(json.getAsJsonObject("_udi"), res.getUdiElement());
    if (json.has("lotNumber"))
      res.setLotNumberElement(parseString(json.get("lotNumber").getAsString()));
    if (json.has("_lotNumber"))
      parseElementProperties(json.getAsJsonObject("_lotNumber"), res.getLotNumberElement());
    if (json.has("owner"))
      res.setOwner(parseReference(json.getAsJsonObject("owner")));
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    return res;
  }

  protected DeviceComponent parseDeviceComponent(JsonObject json) throws IOException, FHIRFormatError {
    DeviceComponent res = new DeviceComponent();
    parseDomainResourceProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("lastSystemChange"))
      res.setLastSystemChangeElement(parseInstant(json.get("lastSystemChange").getAsString()));
    if (json.has("_lastSystemChange"))
      parseElementProperties(json.getAsJsonObject("_lastSystemChange"), res.getLastSystemChangeElement());
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("parent"))
      res.setParent(parseReference(json.getAsJsonObject("parent")));
    if (json.has("operationalStatus")) {
      JsonArray array = json.getAsJsonArray("operationalStatus");
      for (int i = 0; i < array.size(); i++) {
        res.getOperationalStatus().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("parameterGroup"))
      res.setParameterGroup(parseCodeableConcept(json.getAsJsonObject("parameterGroup")));
    if (json.has("measurementPrinciple"))
      res.setMeasurementPrincipleElement(parseEnumeration(json.get("measurementPrinciple").getAsString(),
          DeviceComponent.MeasmntPrinciple.NULL, new DeviceComponent.MeasmntPrincipleEnumFactory()));
    if (json.has("_measurementPrinciple"))
      parseElementProperties(json.getAsJsonObject("_measurementPrinciple"), res.getMeasurementPrincipleElement());
    if (json.has("productionSpecification")) {
      JsonArray array = json.getAsJsonArray("productionSpecification");
      for (int i = 0; i < array.size(); i++) {
        res.getProductionSpecification().add(
            parseDeviceComponentDeviceComponentProductionSpecificationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("languageCode"))
      res.setLanguageCode(parseCodeableConcept(json.getAsJsonObject("languageCode")));
    return res;
  }

  protected DeviceComponent.DeviceComponentProductionSpecificationComponent parseDeviceComponentDeviceComponentProductionSpecificationComponent(
      JsonObject json, DeviceComponent owner) throws IOException, FHIRFormatError {
    DeviceComponent.DeviceComponentProductionSpecificationComponent res = new DeviceComponent.DeviceComponentProductionSpecificationComponent();
    parseBackboneProperties(json, res);
    if (json.has("specType"))
      res.setSpecType(parseCodeableConcept(json.getAsJsonObject("specType")));
    if (json.has("componentId"))
      res.setComponentId(parseIdentifier(json.getAsJsonObject("componentId")));
    if (json.has("productionSpec"))
      res.setProductionSpecElement(parseString(json.get("productionSpec").getAsString()));
    if (json.has("_productionSpec"))
      parseElementProperties(json.getAsJsonObject("_productionSpec"), res.getProductionSpecElement());
    return res;
  }

  protected DeviceMetric parseDeviceMetric(JsonObject json) throws IOException, FHIRFormatError {
    DeviceMetric res = new DeviceMetric();
    parseDomainResourceProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("unit"))
      res.setUnit(parseCodeableConcept(json.getAsJsonObject("unit")));
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("parent"))
      res.setParent(parseReference(json.getAsJsonObject("parent")));
    if (json.has("operationalStatus"))
      res.setOperationalStatusElement(
          parseEnumeration(json.get("operationalStatus").getAsString(), DeviceMetric.DeviceMetricOperationalStatus.NULL,
              new DeviceMetric.DeviceMetricOperationalStatusEnumFactory()));
    if (json.has("_operationalStatus"))
      parseElementProperties(json.getAsJsonObject("_operationalStatus"), res.getOperationalStatusElement());
    if (json.has("color"))
      res.setColorElement(parseEnumeration(json.get("color").getAsString(), DeviceMetric.DeviceMetricColor.NULL,
          new DeviceMetric.DeviceMetricColorEnumFactory()));
    if (json.has("_color"))
      parseElementProperties(json.getAsJsonObject("_color"), res.getColorElement());
    if (json.has("category"))
      res.setCategoryElement(parseEnumeration(json.get("category").getAsString(),
          DeviceMetric.DeviceMetricCategory.NULL, new DeviceMetric.DeviceMetricCategoryEnumFactory()));
    if (json.has("_category"))
      parseElementProperties(json.getAsJsonObject("_category"), res.getCategoryElement());
    if (json.has("measurementPeriod"))
      res.setMeasurementPeriod(parseTiming(json.getAsJsonObject("measurementPeriod")));
    if (json.has("calibration")) {
      JsonArray array = json.getAsJsonArray("calibration");
      for (int i = 0; i < array.size(); i++) {
        res.getCalibration()
            .add(parseDeviceMetricDeviceMetricCalibrationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected DeviceMetric.DeviceMetricCalibrationComponent parseDeviceMetricDeviceMetricCalibrationComponent(
      JsonObject json, DeviceMetric owner) throws IOException, FHIRFormatError {
    DeviceMetric.DeviceMetricCalibrationComponent res = new DeviceMetric.DeviceMetricCalibrationComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), DeviceMetric.DeviceMetricCalibrationType.NULL,
          new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("state"))
      res.setStateElement(parseEnumeration(json.get("state").getAsString(),
          DeviceMetric.DeviceMetricCalibrationState.NULL, new DeviceMetric.DeviceMetricCalibrationStateEnumFactory()));
    if (json.has("_state"))
      parseElementProperties(json.getAsJsonObject("_state"), res.getStateElement());
    if (json.has("time"))
      res.setTimeElement(parseInstant(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(json.getAsJsonObject("_time"), res.getTimeElement());
    return res;
  }

  protected DeviceUseRequest parseDeviceUseRequest(JsonObject json) throws IOException, FHIRFormatError {
    DeviceUseRequest res = new DeviceUseRequest();
    parseDomainResourceProperties(json, res);
    Type bodySite = parseType("bodySite", json);
    if (bodySite != null)
      res.setBodySite(bodySite);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          DeviceUseRequest.DeviceUseRequestStatus.NULL, new DeviceUseRequest.DeviceUseRequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("device"))
      res.setDevice(parseReference(json.getAsJsonObject("device")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("indication")) {
      JsonArray array = json.getAsJsonArray("indication");
      for (int i = 0; i < array.size(); i++) {
        res.getIndication().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("notes")) {
      JsonArray array = json.getAsJsonArray("notes");
      for (int i = 0; i < array.size(); i++) {
        res.getNotes().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_notes")) {
      JsonArray array = json.getAsJsonArray("_notes");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getNotes().size())
          res.getNotes().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getNotes().get(i));
      }
    }
    ;
    if (json.has("prnReason")) {
      JsonArray array = json.getAsJsonArray("prnReason");
      for (int i = 0; i < array.size(); i++) {
        res.getPrnReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("orderedOn"))
      res.setOrderedOnElement(parseDateTime(json.get("orderedOn").getAsString()));
    if (json.has("_orderedOn"))
      parseElementProperties(json.getAsJsonObject("_orderedOn"), res.getOrderedOnElement());
    if (json.has("recordedOn"))
      res.setRecordedOnElement(parseDateTime(json.get("recordedOn").getAsString()));
    if (json.has("_recordedOn"))
      parseElementProperties(json.getAsJsonObject("_recordedOn"), res.getRecordedOnElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    Type timing = parseType("timing", json);
    if (timing != null)
      res.setTiming(timing);
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(),
          DeviceUseRequest.DeviceUseRequestPriority.NULL, new DeviceUseRequest.DeviceUseRequestPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(json.getAsJsonObject("_priority"), res.getPriorityElement());
    return res;
  }

  protected DeviceUseStatement parseDeviceUseStatement(JsonObject json) throws IOException, FHIRFormatError {
    DeviceUseStatement res = new DeviceUseStatement();
    parseDomainResourceProperties(json, res);
    Type bodySite = parseType("bodySite", json);
    if (bodySite != null)
      res.setBodySite(bodySite);
    if (json.has("whenUsed"))
      res.setWhenUsed(parsePeriod(json.getAsJsonObject("whenUsed")));
    if (json.has("device"))
      res.setDevice(parseReference(json.getAsJsonObject("device")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("indication")) {
      JsonArray array = json.getAsJsonArray("indication");
      for (int i = 0; i < array.size(); i++) {
        res.getIndication().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("notes")) {
      JsonArray array = json.getAsJsonArray("notes");
      for (int i = 0; i < array.size(); i++) {
        res.getNotes().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_notes")) {
      JsonArray array = json.getAsJsonArray("_notes");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getNotes().size())
          res.getNotes().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getNotes().get(i));
      }
    }
    ;
    if (json.has("recordedOn"))
      res.setRecordedOnElement(parseDateTime(json.get("recordedOn").getAsString()));
    if (json.has("_recordedOn"))
      parseElementProperties(json.getAsJsonObject("_recordedOn"), res.getRecordedOnElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    Type timing = parseType("timing", json);
    if (timing != null)
      res.setTiming(timing);
    return res;
  }

  protected DiagnosticOrder parseDiagnosticOrder(JsonObject json) throws IOException, FHIRFormatError {
    DiagnosticOrder res = new DiagnosticOrder();
    parseDomainResourceProperties(json, res);
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("orderer"))
      res.setOrderer(parseReference(json.getAsJsonObject("orderer")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("supportingInformation")) {
      JsonArray array = json.getAsJsonArray("supportingInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("specimen")) {
      JsonArray array = json.getAsJsonArray("specimen");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecimen().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(),
          DiagnosticOrder.DiagnosticOrderPriority.NULL, new DiagnosticOrder.DiagnosticOrderPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(json.getAsJsonObject("_priority"), res.getPriorityElement());
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseDiagnosticOrderDiagnosticOrderEventComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("item")) {
      JsonArray array = json.getAsJsonArray("item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseDiagnosticOrderDiagnosticOrderItemComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DiagnosticOrder.DiagnosticOrderEventComponent parseDiagnosticOrderDiagnosticOrderEventComponent(
      JsonObject json, DiagnosticOrder owner) throws IOException, FHIRFormatError {
    DiagnosticOrder.DiagnosticOrderEventComponent res = new DiagnosticOrder.DiagnosticOrderEventComponent();
    parseBackboneProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("description"))
      res.setDescription(parseCodeableConcept(json.getAsJsonObject("description")));
    if (json.has("dateTime"))
      res.setDateTimeElement(parseDateTime(json.get("dateTime").getAsString()));
    if (json.has("_dateTime"))
      parseElementProperties(json.getAsJsonObject("_dateTime"), res.getDateTimeElement());
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    return res;
  }

  protected DiagnosticOrder.DiagnosticOrderItemComponent parseDiagnosticOrderDiagnosticOrderItemComponent(
      JsonObject json, DiagnosticOrder owner) throws IOException, FHIRFormatError {
    DiagnosticOrder.DiagnosticOrderItemComponent res = new DiagnosticOrder.DiagnosticOrderItemComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("specimen")) {
      JsonArray array = json.getAsJsonArray("specimen");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecimen().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("bodySite"))
      res.setBodySite(parseCodeableConcept(json.getAsJsonObject("bodySite")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseDiagnosticOrderDiagnosticOrderEventComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected DiagnosticReport parseDiagnosticReport(JsonObject json) throws IOException, FHIRFormatError {
    DiagnosticReport res = new DiagnosticReport();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          DiagnosticReport.DiagnosticReportStatus.NULL, new DiagnosticReport.DiagnosticReportStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    Type effective = parseType("effective", json);
    if (effective != null)
      res.setEffective(effective);
    if (json.has("issued"))
      res.setIssuedElement(parseInstant(json.get("issued").getAsString()));
    if (json.has("_issued"))
      parseElementProperties(json.getAsJsonObject("_issued"), res.getIssuedElement());
    if (json.has("performer"))
      res.setPerformer(parseReference(json.getAsJsonObject("performer")));
    if (json.has("request")) {
      JsonArray array = json.getAsJsonArray("request");
      for (int i = 0; i < array.size(); i++) {
        res.getRequest().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("specimen")) {
      JsonArray array = json.getAsJsonArray("specimen");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecimen().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("result")) {
      JsonArray array = json.getAsJsonArray("result");
      for (int i = 0; i < array.size(); i++) {
        res.getResult().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("imagingStudy")) {
      JsonArray array = json.getAsJsonArray("imagingStudy");
      for (int i = 0; i < array.size(); i++) {
        res.getImagingStudy().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("image")) {
      JsonArray array = json.getAsJsonArray("image");
      for (int i = 0; i < array.size(); i++) {
        res.getImage().add(parseDiagnosticReportDiagnosticReportImageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("conclusion"))
      res.setConclusionElement(parseString(json.get("conclusion").getAsString()));
    if (json.has("_conclusion"))
      parseElementProperties(json.getAsJsonObject("_conclusion"), res.getConclusionElement());
    if (json.has("codedDiagnosis")) {
      JsonArray array = json.getAsJsonArray("codedDiagnosis");
      for (int i = 0; i < array.size(); i++) {
        res.getCodedDiagnosis().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("presentedForm")) {
      JsonArray array = json.getAsJsonArray("presentedForm");
      for (int i = 0; i < array.size(); i++) {
        res.getPresentedForm().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DiagnosticReport.DiagnosticReportImageComponent parseDiagnosticReportDiagnosticReportImageComponent(
      JsonObject json, DiagnosticReport owner) throws IOException, FHIRFormatError {
    DiagnosticReport.DiagnosticReportImageComponent res = new DiagnosticReport.DiagnosticReportImageComponent();
    parseBackboneProperties(json, res);
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    if (json.has("link"))
      res.setLink(parseReference(json.getAsJsonObject("link")));
    return res;
  }

  protected DocumentManifest parseDocumentManifest(JsonObject json) throws IOException, FHIRFormatError {
    DocumentManifest res = new DocumentManifest();
    parseDomainResourceProperties(json, res);
    if (json.has("masterIdentifier"))
      res.setMasterIdentifier(parseIdentifier(json.getAsJsonObject("masterIdentifier")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("recipient")) {
      JsonArray array = json.getAsJsonArray("recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("author")) {
      JsonArray array = json.getAsJsonArray("author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("source"))
      res.setSourceElement(parseUri(json.get("source").getAsString()));
    if (json.has("_source"))
      parseElementProperties(json.getAsJsonObject("_source"), res.getSourceElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.DocumentReferenceStatus.NULL,
          new Enumerations.DocumentReferenceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("content")) {
      JsonArray array = json.getAsJsonArray("content");
      for (int i = 0; i < array.size(); i++) {
        res.getContent()
            .add(parseDocumentManifestDocumentManifestContentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("related")) {
      JsonArray array = json.getAsJsonArray("related");
      for (int i = 0; i < array.size(); i++) {
        res.getRelated()
            .add(parseDocumentManifestDocumentManifestRelatedComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected DocumentManifest.DocumentManifestContentComponent parseDocumentManifestDocumentManifestContentComponent(
      JsonObject json, DocumentManifest owner) throws IOException, FHIRFormatError {
    DocumentManifest.DocumentManifestContentComponent res = new DocumentManifest.DocumentManifestContentComponent();
    parseBackboneProperties(json, res);
    Type p = parseType("p", json);
    if (p != null)
      res.setP(p);
    return res;
  }

  protected DocumentManifest.DocumentManifestRelatedComponent parseDocumentManifestDocumentManifestRelatedComponent(
      JsonObject json, DocumentManifest owner) throws IOException, FHIRFormatError {
    DocumentManifest.DocumentManifestRelatedComponent res = new DocumentManifest.DocumentManifestRelatedComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("ref"))
      res.setRef(parseReference(json.getAsJsonObject("ref")));
    return res;
  }

  protected DocumentReference parseDocumentReference(JsonObject json) throws IOException, FHIRFormatError {
    DocumentReference res = new DocumentReference();
    parseDomainResourceProperties(json, res);
    if (json.has("masterIdentifier"))
      res.setMasterIdentifier(parseIdentifier(json.getAsJsonObject("masterIdentifier")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("class"))
      res.setClass_(parseCodeableConcept(json.getAsJsonObject("class")));
    if (json.has("author")) {
      JsonArray array = json.getAsJsonArray("author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("custodian"))
      res.setCustodian(parseReference(json.getAsJsonObject("custodian")));
    if (json.has("authenticator"))
      res.setAuthenticator(parseReference(json.getAsJsonObject("authenticator")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("indexed"))
      res.setIndexedElement(parseInstant(json.get("indexed").getAsString()));
    if (json.has("_indexed"))
      parseElementProperties(json.getAsJsonObject("_indexed"), res.getIndexedElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.DocumentReferenceStatus.NULL,
          new Enumerations.DocumentReferenceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("docStatus"))
      res.setDocStatus(parseCodeableConcept(json.getAsJsonObject("docStatus")));
    if (json.has("relatesTo")) {
      JsonArray array = json.getAsJsonArray("relatesTo");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatesTo()
            .add(parseDocumentReferenceDocumentReferenceRelatesToComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("securityLabel")) {
      JsonArray array = json.getAsJsonArray("securityLabel");
      for (int i = 0; i < array.size(); i++) {
        res.getSecurityLabel().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("content")) {
      JsonArray array = json.getAsJsonArray("content");
      for (int i = 0; i < array.size(); i++) {
        res.getContent()
            .add(parseDocumentReferenceDocumentReferenceContentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("context"))
      res.setContext(parseDocumentReferenceDocumentReferenceContextComponent(json.getAsJsonObject("context"), res));
    return res;
  }

  protected DocumentReference.DocumentReferenceRelatesToComponent parseDocumentReferenceDocumentReferenceRelatesToComponent(
      JsonObject json, DocumentReference owner) throws IOException, FHIRFormatError {
    DocumentReference.DocumentReferenceRelatesToComponent res = new DocumentReference.DocumentReferenceRelatesToComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(
          parseEnumeration(json.get("code").getAsString(), DocumentReference.DocumentRelationshipType.NULL,
              new DocumentReference.DocumentRelationshipTypeEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    return res;
  }

  protected DocumentReference.DocumentReferenceContentComponent parseDocumentReferenceDocumentReferenceContentComponent(
      JsonObject json, DocumentReference owner) throws IOException, FHIRFormatError {
    DocumentReference.DocumentReferenceContentComponent res = new DocumentReference.DocumentReferenceContentComponent();
    parseBackboneProperties(json, res);
    if (json.has("attachment"))
      res.setAttachment(parseAttachment(json.getAsJsonObject("attachment")));
    if (json.has("format")) {
      JsonArray array = json.getAsJsonArray("format");
      for (int i = 0; i < array.size(); i++) {
        res.getFormat().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected DocumentReference.DocumentReferenceContextComponent parseDocumentReferenceDocumentReferenceContextComponent(
      JsonObject json, DocumentReference owner) throws IOException, FHIRFormatError {
    DocumentReference.DocumentReferenceContextComponent res = new DocumentReference.DocumentReferenceContextComponent();
    parseBackboneProperties(json, res);
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("event")) {
      JsonArray array = json.getAsJsonArray("event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("facilityType"))
      res.setFacilityType(parseCodeableConcept(json.getAsJsonObject("facilityType")));
    if (json.has("practiceSetting"))
      res.setPracticeSetting(parseCodeableConcept(json.getAsJsonObject("practiceSetting")));
    if (json.has("sourcePatientInfo"))
      res.setSourcePatientInfo(parseReference(json.getAsJsonObject("sourcePatientInfo")));
    if (json.has("related")) {
      JsonArray array = json.getAsJsonArray("related");
      for (int i = 0; i < array.size(); i++) {
        res.getRelated()
            .add(parseDocumentReferenceDocumentReferenceContextRelatedComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected DocumentReference.DocumentReferenceContextRelatedComponent parseDocumentReferenceDocumentReferenceContextRelatedComponent(
      JsonObject json, DocumentReference owner) throws IOException, FHIRFormatError {
    DocumentReference.DocumentReferenceContextRelatedComponent res = new DocumentReference.DocumentReferenceContextRelatedComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("ref"))
      res.setRef(parseReference(json.getAsJsonObject("ref")));
    return res;
  }

  protected EligibilityRequest parseEligibilityRequest(JsonObject json) throws IOException, FHIRFormatError {
    EligibilityRequest res = new EligibilityRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    return res;
  }

  protected EligibilityResponse parseEligibilityResponse(JsonObject json) throws IOException, FHIRFormatError {
    EligibilityResponse res = new EligibilityResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.RemittanceOutcome.NULL,
          new Enumerations.RemittanceOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    return res;
  }

  protected Encounter parseEncounter(JsonObject json) throws IOException, FHIRFormatError {
    Encounter res = new Encounter();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Encounter.EncounterState.NULL,
          new Encounter.EncounterStateEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("statusHistory")) {
      JsonArray array = json.getAsJsonArray("statusHistory");
      for (int i = 0; i < array.size(); i++) {
        res.getStatusHistory().add(parseEncounterEncounterStatusHistoryComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("class"))
      res.setClass_Element(parseEnumeration(json.get("class").getAsString(), Encounter.EncounterClass.NULL,
          new Encounter.EncounterClassEnumFactory()));
    if (json.has("_class"))
      parseElementProperties(json.getAsJsonObject("_class"), res.getClass_Element());
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(json.getAsJsonObject("priority")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("episodeOfCare")) {
      JsonArray array = json.getAsJsonArray("episodeOfCare");
      for (int i = 0; i < array.size(); i++) {
        res.getEpisodeOfCare().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("incomingReferral")) {
      JsonArray array = json.getAsJsonArray("incomingReferral");
      for (int i = 0; i < array.size(); i++) {
        res.getIncomingReferral().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("participant")) {
      JsonArray array = json.getAsJsonArray("participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseEncounterEncounterParticipantComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("appointment"))
      res.setAppointment(parseReference(json.getAsJsonObject("appointment")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("length"))
      res.setLength(parseDuration(json.getAsJsonObject("length")));
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("indication")) {
      JsonArray array = json.getAsJsonArray("indication");
      for (int i = 0; i < array.size(); i++) {
        res.getIndication().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("hospitalization"))
      res.setHospitalization(
          parseEncounterEncounterHospitalizationComponent(json.getAsJsonObject("hospitalization"), res));
    if (json.has("location")) {
      JsonArray array = json.getAsJsonArray("location");
      for (int i = 0; i < array.size(); i++) {
        res.getLocation().add(parseEncounterEncounterLocationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("serviceProvider"))
      res.setServiceProvider(parseReference(json.getAsJsonObject("serviceProvider")));
    if (json.has("partOf"))
      res.setPartOf(parseReference(json.getAsJsonObject("partOf")));
    return res;
  }

  protected Encounter.EncounterStatusHistoryComponent parseEncounterEncounterStatusHistoryComponent(JsonObject json,
      Encounter owner) throws IOException, FHIRFormatError {
    Encounter.EncounterStatusHistoryComponent res = new Encounter.EncounterStatusHistoryComponent();
    parseBackboneProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Encounter.EncounterState.NULL,
          new Encounter.EncounterStateEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected Encounter.EncounterParticipantComponent parseEncounterEncounterParticipantComponent(JsonObject json,
      Encounter owner) throws IOException, FHIRFormatError {
    Encounter.EncounterParticipantComponent res = new Encounter.EncounterParticipantComponent();
    parseBackboneProperties(json, res);
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("individual"))
      res.setIndividual(parseReference(json.getAsJsonObject("individual")));
    return res;
  }

  protected Encounter.EncounterHospitalizationComponent parseEncounterEncounterHospitalizationComponent(JsonObject json,
      Encounter owner) throws IOException, FHIRFormatError {
    Encounter.EncounterHospitalizationComponent res = new Encounter.EncounterHospitalizationComponent();
    parseBackboneProperties(json, res);
    if (json.has("preAdmissionIdentifier"))
      res.setPreAdmissionIdentifier(parseIdentifier(json.getAsJsonObject("preAdmissionIdentifier")));
    if (json.has("origin"))
      res.setOrigin(parseReference(json.getAsJsonObject("origin")));
    if (json.has("admitSource"))
      res.setAdmitSource(parseCodeableConcept(json.getAsJsonObject("admitSource")));
    if (json.has("admittingDiagnosis")) {
      JsonArray array = json.getAsJsonArray("admittingDiagnosis");
      for (int i = 0; i < array.size(); i++) {
        res.getAdmittingDiagnosis().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reAdmission"))
      res.setReAdmission(parseCodeableConcept(json.getAsJsonObject("reAdmission")));
    if (json.has("dietPreference")) {
      JsonArray array = json.getAsJsonArray("dietPreference");
      for (int i = 0; i < array.size(); i++) {
        res.getDietPreference().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("specialCourtesy")) {
      JsonArray array = json.getAsJsonArray("specialCourtesy");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialCourtesy().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("specialArrangement")) {
      JsonArray array = json.getAsJsonArray("specialArrangement");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialArrangement().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("destination"))
      res.setDestination(parseReference(json.getAsJsonObject("destination")));
    if (json.has("dischargeDisposition"))
      res.setDischargeDisposition(parseCodeableConcept(json.getAsJsonObject("dischargeDisposition")));
    if (json.has("dischargeDiagnosis")) {
      JsonArray array = json.getAsJsonArray("dischargeDiagnosis");
      for (int i = 0; i < array.size(); i++) {
        res.getDischargeDiagnosis().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Encounter.EncounterLocationComponent parseEncounterEncounterLocationComponent(JsonObject json,
      Encounter owner) throws IOException, FHIRFormatError {
    Encounter.EncounterLocationComponent res = new Encounter.EncounterLocationComponent();
    parseBackboneProperties(json, res);
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Encounter.EncounterLocationStatus.NULL,
          new Encounter.EncounterLocationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected EnrollmentRequest parseEnrollmentRequest(JsonObject json) throws IOException, FHIRFormatError {
    EnrollmentRequest res = new EnrollmentRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("coverage"))
      res.setCoverage(parseReference(json.getAsJsonObject("coverage")));
    if (json.has("relationship"))
      res.setRelationship(parseCoding(json.getAsJsonObject("relationship")));
    return res;
  }

  protected EnrollmentResponse parseEnrollmentResponse(JsonObject json) throws IOException, FHIRFormatError {
    EnrollmentResponse res = new EnrollmentResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.RemittanceOutcome.NULL,
          new Enumerations.RemittanceOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    return res;
  }

  protected EpisodeOfCare parseEpisodeOfCare(JsonObject json) throws IOException, FHIRFormatError {
    EpisodeOfCare res = new EpisodeOfCare();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), EpisodeOfCare.EpisodeOfCareStatus.NULL,
          new EpisodeOfCare.EpisodeOfCareStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("statusHistory")) {
      JsonArray array = json.getAsJsonArray("statusHistory");
      for (int i = 0; i < array.size(); i++) {
        res.getStatusHistory()
            .add(parseEpisodeOfCareEpisodeOfCareStatusHistoryComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("condition")) {
      JsonArray array = json.getAsJsonArray("condition");
      for (int i = 0; i < array.size(); i++) {
        res.getCondition().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("managingOrganization"))
      res.setManagingOrganization(parseReference(json.getAsJsonObject("managingOrganization")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("referralRequest")) {
      JsonArray array = json.getAsJsonArray("referralRequest");
      for (int i = 0; i < array.size(); i++) {
        res.getReferralRequest().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("careManager"))
      res.setCareManager(parseReference(json.getAsJsonObject("careManager")));
    if (json.has("careTeam")) {
      JsonArray array = json.getAsJsonArray("careTeam");
      for (int i = 0; i < array.size(); i++) {
        res.getCareTeam().add(parseEpisodeOfCareEpisodeOfCareCareTeamComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected EpisodeOfCare.EpisodeOfCareStatusHistoryComponent parseEpisodeOfCareEpisodeOfCareStatusHistoryComponent(
      JsonObject json, EpisodeOfCare owner) throws IOException, FHIRFormatError {
    EpisodeOfCare.EpisodeOfCareStatusHistoryComponent res = new EpisodeOfCare.EpisodeOfCareStatusHistoryComponent();
    parseBackboneProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), EpisodeOfCare.EpisodeOfCareStatus.NULL,
          new EpisodeOfCare.EpisodeOfCareStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected EpisodeOfCare.EpisodeOfCareCareTeamComponent parseEpisodeOfCareEpisodeOfCareCareTeamComponent(
      JsonObject json, EpisodeOfCare owner) throws IOException, FHIRFormatError {
    EpisodeOfCare.EpisodeOfCareCareTeamComponent res = new EpisodeOfCare.EpisodeOfCareCareTeamComponent();
    parseBackboneProperties(json, res);
    if (json.has("role")) {
      JsonArray array = json.getAsJsonArray("role");
      for (int i = 0; i < array.size(); i++) {
        res.getRole().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("member"))
      res.setMember(parseReference(json.getAsJsonObject("member")));
    return res;
  }

  protected ExplanationOfBenefit parseExplanationOfBenefit(JsonObject json) throws IOException, FHIRFormatError {
    ExplanationOfBenefit res = new ExplanationOfBenefit();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.RemittanceOutcome.NULL,
          new Enumerations.RemittanceOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    return res;
  }

  protected FamilyMemberHistory parseFamilyMemberHistory(JsonObject json) throws IOException, FHIRFormatError {
    FamilyMemberHistory res = new FamilyMemberHistory();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          FamilyMemberHistory.FamilyHistoryStatus.NULL, new FamilyMemberHistory.FamilyHistoryStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("relationship"))
      res.setRelationship(parseCodeableConcept(json.getAsJsonObject("relationship")));
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    Type born = parseType("born", json);
    if (born != null)
      res.setBorn(born);
    Type age = parseType("age", json);
    if (age != null)
      res.setAge(age);
    Type deceased = parseType("deceased", json);
    if (deceased != null)
      res.setDeceased(deceased);
    if (json.has("note"))
      res.setNote(parseAnnotation(json.getAsJsonObject("note")));
    if (json.has("condition")) {
      JsonArray array = json.getAsJsonArray("condition");
      for (int i = 0; i < array.size(); i++) {
        res.getCondition()
            .add(parseFamilyMemberHistoryFamilyMemberHistoryConditionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected FamilyMemberHistory.FamilyMemberHistoryConditionComponent parseFamilyMemberHistoryFamilyMemberHistoryConditionComponent(
      JsonObject json, FamilyMemberHistory owner) throws IOException, FHIRFormatError {
    FamilyMemberHistory.FamilyMemberHistoryConditionComponent res = new FamilyMemberHistory.FamilyMemberHistoryConditionComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("outcome"))
      res.setOutcome(parseCodeableConcept(json.getAsJsonObject("outcome")));
    Type onset = parseType("onset", json);
    if (onset != null)
      res.setOnset(onset);
    if (json.has("note"))
      res.setNote(parseAnnotation(json.getAsJsonObject("note")));
    return res;
  }

  protected Flag parseFlag(JsonObject json) throws IOException, FHIRFormatError {
    Flag res = new Flag();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), Flag.FlagStatus.NULL, new Flag.FlagStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    return res;
  }

  protected Goal parseGoal(JsonObject json) throws IOException, FHIRFormatError {
    Goal res = new Goal();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    Type start = parseType("start", json);
    if (start != null)
      res.setStart(start);
    Type target = parseType("target", json);
    if (target != null)
      res.setTarget(target);
    if (json.has("category")) {
      JsonArray array = json.getAsJsonArray("category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), Goal.GoalStatus.NULL, new Goal.GoalStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("statusDate"))
      res.setStatusDateElement(parseDate(json.get("statusDate").getAsString()));
    if (json.has("_statusDate"))
      parseElementProperties(json.getAsJsonObject("_statusDate"), res.getStatusDateElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(json.getAsJsonObject("statusReason")));
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(json.getAsJsonObject("priority")));
    if (json.has("addresses")) {
      JsonArray array = json.getAsJsonArray("addresses");
      for (int i = 0; i < array.size(); i++) {
        res.getAddresses().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("outcome")) {
      JsonArray array = json.getAsJsonArray("outcome");
      for (int i = 0; i < array.size(); i++) {
        res.getOutcome().add(parseGoalGoalOutcomeComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Goal.GoalOutcomeComponent parseGoalGoalOutcomeComponent(JsonObject json, Goal owner)
      throws IOException, FHIRFormatError {
    Goal.GoalOutcomeComponent res = new Goal.GoalOutcomeComponent();
    parseBackboneProperties(json, res);
    Type result = parseType("result", json);
    if (result != null)
      res.setResult(result);
    return res;
  }

  protected Group parseGroup(JsonObject json) throws IOException, FHIRFormatError {
    Group res = new Group();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setTypeElement(
          parseEnumeration(json.get("type").getAsString(), Group.GroupType.NULL, new Group.GroupTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("actual"))
      res.setActualElement(parseBoolean(json.get("actual").getAsBoolean()));
    if (json.has("_actual"))
      parseElementProperties(json.getAsJsonObject("_actual"), res.getActualElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("quantity"))
      res.setQuantityElement(parseUnsignedInt(json.get("quantity").getAsString()));
    if (json.has("_quantity"))
      parseElementProperties(json.getAsJsonObject("_quantity"), res.getQuantityElement());
    if (json.has("characteristic")) {
      JsonArray array = json.getAsJsonArray("characteristic");
      for (int i = 0; i < array.size(); i++) {
        res.getCharacteristic().add(parseGroupGroupCharacteristicComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("member")) {
      JsonArray array = json.getAsJsonArray("member");
      for (int i = 0; i < array.size(); i++) {
        res.getMember().add(parseGroupGroupMemberComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Group.GroupCharacteristicComponent parseGroupGroupCharacteristicComponent(JsonObject json, Group owner)
      throws IOException, FHIRFormatError {
    Group.GroupCharacteristicComponent res = new Group.GroupCharacteristicComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("exclude"))
      res.setExcludeElement(parseBoolean(json.get("exclude").getAsBoolean()));
    if (json.has("_exclude"))
      parseElementProperties(json.getAsJsonObject("_exclude"), res.getExcludeElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected Group.GroupMemberComponent parseGroupGroupMemberComponent(JsonObject json, Group owner)
      throws IOException, FHIRFormatError {
    Group.GroupMemberComponent res = new Group.GroupMemberComponent();
    parseBackboneProperties(json, res);
    if (json.has("entity"))
      res.setEntity(parseReference(json.getAsJsonObject("entity")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("inactive"))
      res.setInactiveElement(parseBoolean(json.get("inactive").getAsBoolean()));
    if (json.has("_inactive"))
      parseElementProperties(json.getAsJsonObject("_inactive"), res.getInactiveElement());
    return res;
  }

  protected HealthcareService parseHealthcareService(JsonObject json) throws IOException, FHIRFormatError {
    HealthcareService res = new HealthcareService();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("providedBy"))
      res.setProvidedBy(parseReference(json.getAsJsonObject("providedBy")));
    if (json.has("serviceCategory"))
      res.setServiceCategory(parseCodeableConcept(json.getAsJsonObject("serviceCategory")));
    if (json.has("serviceType")) {
      JsonArray array = json.getAsJsonArray("serviceType");
      for (int i = 0; i < array.size(); i++) {
        res.getServiceType().add(parseHealthcareServiceServiceTypeComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("serviceName"))
      res.setServiceNameElement(parseString(json.get("serviceName").getAsString()));
    if (json.has("_serviceName"))
      parseElementProperties(json.getAsJsonObject("_serviceName"), res.getServiceNameElement());
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    if (json.has("extraDetails"))
      res.setExtraDetailsElement(parseString(json.get("extraDetails").getAsString()));
    if (json.has("_extraDetails"))
      parseElementProperties(json.getAsJsonObject("_extraDetails"), res.getExtraDetailsElement());
    if (json.has("photo"))
      res.setPhoto(parseAttachment(json.getAsJsonObject("photo")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("coverageArea")) {
      JsonArray array = json.getAsJsonArray("coverageArea");
      for (int i = 0; i < array.size(); i++) {
        res.getCoverageArea().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("serviceProvisionCode")) {
      JsonArray array = json.getAsJsonArray("serviceProvisionCode");
      for (int i = 0; i < array.size(); i++) {
        res.getServiceProvisionCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("eligibility"))
      res.setEligibility(parseCodeableConcept(json.getAsJsonObject("eligibility")));
    if (json.has("eligibilityNote"))
      res.setEligibilityNoteElement(parseString(json.get("eligibilityNote").getAsString()));
    if (json.has("_eligibilityNote"))
      parseElementProperties(json.getAsJsonObject("_eligibilityNote"), res.getEligibilityNoteElement());
    if (json.has("programName")) {
      JsonArray array = json.getAsJsonArray("programName");
      for (int i = 0; i < array.size(); i++) {
        res.getProgramName().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_programName")) {
      JsonArray array = json.getAsJsonArray("_programName");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProgramName().size())
          res.getProgramName().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProgramName().get(i));
      }
    }
    ;
    if (json.has("characteristic")) {
      JsonArray array = json.getAsJsonArray("characteristic");
      for (int i = 0; i < array.size(); i++) {
        res.getCharacteristic().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("referralMethod")) {
      JsonArray array = json.getAsJsonArray("referralMethod");
      for (int i = 0; i < array.size(); i++) {
        res.getReferralMethod().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("publicKey"))
      res.setPublicKeyElement(parseString(json.get("publicKey").getAsString()));
    if (json.has("_publicKey"))
      parseElementProperties(json.getAsJsonObject("_publicKey"), res.getPublicKeyElement());
    if (json.has("appointmentRequired"))
      res.setAppointmentRequiredElement(parseBoolean(json.get("appointmentRequired").getAsBoolean()));
    if (json.has("_appointmentRequired"))
      parseElementProperties(json.getAsJsonObject("_appointmentRequired"), res.getAppointmentRequiredElement());
    if (json.has("availableTime")) {
      JsonArray array = json.getAsJsonArray("availableTime");
      for (int i = 0; i < array.size(); i++) {
        res.getAvailableTime()
            .add(parseHealthcareServiceHealthcareServiceAvailableTimeComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("notAvailable")) {
      JsonArray array = json.getAsJsonArray("notAvailable");
      for (int i = 0; i < array.size(); i++) {
        res.getNotAvailable()
            .add(parseHealthcareServiceHealthcareServiceNotAvailableComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("availabilityExceptions"))
      res.setAvailabilityExceptionsElement(parseString(json.get("availabilityExceptions").getAsString()));
    if (json.has("_availabilityExceptions"))
      parseElementProperties(json.getAsJsonObject("_availabilityExceptions"), res.getAvailabilityExceptionsElement());
    return res;
  }

  protected HealthcareService.ServiceTypeComponent parseHealthcareServiceServiceTypeComponent(JsonObject json,
      HealthcareService owner) throws IOException, FHIRFormatError {
    HealthcareService.ServiceTypeComponent res = new HealthcareService.ServiceTypeComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("specialty")) {
      JsonArray array = json.getAsJsonArray("specialty");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialty().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected HealthcareService.HealthcareServiceAvailableTimeComponent parseHealthcareServiceHealthcareServiceAvailableTimeComponent(
      JsonObject json, HealthcareService owner) throws IOException, FHIRFormatError {
    HealthcareService.HealthcareServiceAvailableTimeComponent res = new HealthcareService.HealthcareServiceAvailableTimeComponent();
    parseBackboneProperties(json, res);
    if (json.has("daysOfWeek")) {
      JsonArray array = json.getAsJsonArray("daysOfWeek");
      for (int i = 0; i < array.size(); i++) {
        res.getDaysOfWeek().add(parseEnumeration(array.get(i).getAsString(), HealthcareService.DaysOfWeek.NULL,
            new HealthcareService.DaysOfWeekEnumFactory()));
      }
    }
    ;
    if (json.has("_daysOfWeek")) {
      JsonArray array = json.getAsJsonArray("_daysOfWeek");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDaysOfWeek().size())
          res.getDaysOfWeek().add(
              parseEnumeration(null, HealthcareService.DaysOfWeek.NULL, new HealthcareService.DaysOfWeekEnumFactory()));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDaysOfWeek().get(i));
      }
    }
    ;
    if (json.has("allDay"))
      res.setAllDayElement(parseBoolean(json.get("allDay").getAsBoolean()));
    if (json.has("_allDay"))
      parseElementProperties(json.getAsJsonObject("_allDay"), res.getAllDayElement());
    if (json.has("availableStartTime"))
      res.setAvailableStartTimeElement(parseTime(json.get("availableStartTime").getAsString()));
    if (json.has("_availableStartTime"))
      parseElementProperties(json.getAsJsonObject("_availableStartTime"), res.getAvailableStartTimeElement());
    if (json.has("availableEndTime"))
      res.setAvailableEndTimeElement(parseTime(json.get("availableEndTime").getAsString()));
    if (json.has("_availableEndTime"))
      parseElementProperties(json.getAsJsonObject("_availableEndTime"), res.getAvailableEndTimeElement());
    return res;
  }

  protected HealthcareService.HealthcareServiceNotAvailableComponent parseHealthcareServiceHealthcareServiceNotAvailableComponent(
      JsonObject json, HealthcareService owner) throws IOException, FHIRFormatError {
    HealthcareService.HealthcareServiceNotAvailableComponent res = new HealthcareService.HealthcareServiceNotAvailableComponent();
    parseBackboneProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("during"))
      res.setDuring(parsePeriod(json.getAsJsonObject("during")));
    return res;
  }

  protected ImagingObjectSelection parseImagingObjectSelection(JsonObject json) throws IOException, FHIRFormatError {
    ImagingObjectSelection res = new ImagingObjectSelection();
    parseDomainResourceProperties(json, res);
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("title"))
      res.setTitle(parseCodeableConcept(json.getAsJsonObject("title")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("authoringTime"))
      res.setAuthoringTimeElement(parseDateTime(json.get("authoringTime").getAsString()));
    if (json.has("_authoringTime"))
      parseElementProperties(json.getAsJsonObject("_authoringTime"), res.getAuthoringTimeElement());
    if (json.has("study")) {
      JsonArray array = json.getAsJsonArray("study");
      for (int i = 0; i < array.size(); i++) {
        res.getStudy().add(parseImagingObjectSelectionStudyComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ImagingObjectSelection.StudyComponent parseImagingObjectSelectionStudyComponent(JsonObject json,
      ImagingObjectSelection owner) throws IOException, FHIRFormatError {
    ImagingObjectSelection.StudyComponent res = new ImagingObjectSelection.StudyComponent();
    parseBackboneProperties(json, res);
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("imagingStudy"))
      res.setImagingStudy(parseReference(json.getAsJsonObject("imagingStudy")));
    if (json.has("series")) {
      JsonArray array = json.getAsJsonArray("series");
      for (int i = 0; i < array.size(); i++) {
        res.getSeries().add(parseImagingObjectSelectionSeriesComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ImagingObjectSelection.SeriesComponent parseImagingObjectSelectionSeriesComponent(JsonObject json,
      ImagingObjectSelection owner) throws IOException, FHIRFormatError {
    ImagingObjectSelection.SeriesComponent res = new ImagingObjectSelection.SeriesComponent();
    parseBackboneProperties(json, res);
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("instance")) {
      JsonArray array = json.getAsJsonArray("instance");
      for (int i = 0; i < array.size(); i++) {
        res.getInstance().add(parseImagingObjectSelectionInstanceComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ImagingObjectSelection.InstanceComponent parseImagingObjectSelectionInstanceComponent(JsonObject json,
      ImagingObjectSelection owner) throws IOException, FHIRFormatError {
    ImagingObjectSelection.InstanceComponent res = new ImagingObjectSelection.InstanceComponent();
    parseBackboneProperties(json, res);
    if (json.has("sopClass"))
      res.setSopClassElement(parseOid(json.get("sopClass").getAsString()));
    if (json.has("_sopClass"))
      parseElementProperties(json.getAsJsonObject("_sopClass"), res.getSopClassElement());
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("frames")) {
      JsonArray array = json.getAsJsonArray("frames");
      for (int i = 0; i < array.size(); i++) {
        res.getFrames().add(parseImagingObjectSelectionFramesComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ImagingObjectSelection.FramesComponent parseImagingObjectSelectionFramesComponent(JsonObject json,
      ImagingObjectSelection owner) throws IOException, FHIRFormatError {
    ImagingObjectSelection.FramesComponent res = new ImagingObjectSelection.FramesComponent();
    parseBackboneProperties(json, res);
    if (json.has("frameNumbers")) {
      JsonArray array = json.getAsJsonArray("frameNumbers");
      for (int i = 0; i < array.size(); i++) {
        res.getFrameNumbers().add(parseUnsignedInt(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_frameNumbers")) {
      JsonArray array = json.getAsJsonArray("_frameNumbers");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getFrameNumbers().size())
          res.getFrameNumbers().add(parseUnsignedInt(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getFrameNumbers().get(i));
      }
    }
    ;
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    return res;
  }

  protected ImagingStudy parseImagingStudy(JsonObject json) throws IOException, FHIRFormatError {
    ImagingStudy res = new ImagingStudy();
    parseDomainResourceProperties(json, res);
    if (json.has("started"))
      res.setStartedElement(parseDateTime(json.get("started").getAsString()));
    if (json.has("_started"))
      parseElementProperties(json.getAsJsonObject("_started"), res.getStartedElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("accession"))
      res.setAccession(parseIdentifier(json.getAsJsonObject("accession")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("order")) {
      JsonArray array = json.getAsJsonArray("order");
      for (int i = 0; i < array.size(); i++) {
        res.getOrder().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("modalityList")) {
      JsonArray array = json.getAsJsonArray("modalityList");
      for (int i = 0; i < array.size(); i++) {
        res.getModalityList().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("referrer"))
      res.setReferrer(parseReference(json.getAsJsonObject("referrer")));
    if (json.has("availability"))
      res.setAvailabilityElement(parseEnumeration(json.get("availability").getAsString(),
          ImagingStudy.InstanceAvailability.NULL, new ImagingStudy.InstanceAvailabilityEnumFactory()));
    if (json.has("_availability"))
      parseElementProperties(json.getAsJsonObject("_availability"), res.getAvailabilityElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("numberOfSeries"))
      res.setNumberOfSeriesElement(parseUnsignedInt(json.get("numberOfSeries").getAsString()));
    if (json.has("_numberOfSeries"))
      parseElementProperties(json.getAsJsonObject("_numberOfSeries"), res.getNumberOfSeriesElement());
    if (json.has("numberOfInstances"))
      res.setNumberOfInstancesElement(parseUnsignedInt(json.get("numberOfInstances").getAsString()));
    if (json.has("_numberOfInstances"))
      parseElementProperties(json.getAsJsonObject("_numberOfInstances"), res.getNumberOfInstancesElement());
    if (json.has("procedure")) {
      JsonArray array = json.getAsJsonArray("procedure");
      for (int i = 0; i < array.size(); i++) {
        res.getProcedure().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("interpreter"))
      res.setInterpreter(parseReference(json.getAsJsonObject("interpreter")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("series")) {
      JsonArray array = json.getAsJsonArray("series");
      for (int i = 0; i < array.size(); i++) {
        res.getSeries().add(parseImagingStudyImagingStudySeriesComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ImagingStudy.ImagingStudySeriesComponent parseImagingStudyImagingStudySeriesComponent(JsonObject json,
      ImagingStudy owner) throws IOException, FHIRFormatError {
    ImagingStudy.ImagingStudySeriesComponent res = new ImagingStudy.ImagingStudySeriesComponent();
    parseBackboneProperties(json, res);
    if (json.has("number"))
      res.setNumberElement(parseUnsignedInt(json.get("number").getAsString()));
    if (json.has("_number"))
      parseElementProperties(json.getAsJsonObject("_number"), res.getNumberElement());
    if (json.has("modality"))
      res.setModality(parseCoding(json.getAsJsonObject("modality")));
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("numberOfInstances"))
      res.setNumberOfInstancesElement(parseUnsignedInt(json.get("numberOfInstances").getAsString()));
    if (json.has("_numberOfInstances"))
      parseElementProperties(json.getAsJsonObject("_numberOfInstances"), res.getNumberOfInstancesElement());
    if (json.has("availability"))
      res.setAvailabilityElement(parseEnumeration(json.get("availability").getAsString(),
          ImagingStudy.InstanceAvailability.NULL, new ImagingStudy.InstanceAvailabilityEnumFactory()));
    if (json.has("_availability"))
      parseElementProperties(json.getAsJsonObject("_availability"), res.getAvailabilityElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("bodySite"))
      res.setBodySite(parseCoding(json.getAsJsonObject("bodySite")));
    if (json.has("laterality"))
      res.setLaterality(parseCoding(json.getAsJsonObject("laterality")));
    if (json.has("started"))
      res.setStartedElement(parseDateTime(json.get("started").getAsString()));
    if (json.has("_started"))
      parseElementProperties(json.getAsJsonObject("_started"), res.getStartedElement());
    if (json.has("instance")) {
      JsonArray array = json.getAsJsonArray("instance");
      for (int i = 0; i < array.size(); i++) {
        res.getInstance()
            .add(parseImagingStudyImagingStudySeriesInstanceComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ImagingStudy.ImagingStudySeriesInstanceComponent parseImagingStudyImagingStudySeriesInstanceComponent(
      JsonObject json, ImagingStudy owner) throws IOException, FHIRFormatError {
    ImagingStudy.ImagingStudySeriesInstanceComponent res = new ImagingStudy.ImagingStudySeriesInstanceComponent();
    parseBackboneProperties(json, res);
    if (json.has("number"))
      res.setNumberElement(parseUnsignedInt(json.get("number").getAsString()));
    if (json.has("_number"))
      parseElementProperties(json.getAsJsonObject("_number"), res.getNumberElement());
    if (json.has("uid"))
      res.setUidElement(parseOid(json.get("uid").getAsString()));
    if (json.has("_uid"))
      parseElementProperties(json.getAsJsonObject("_uid"), res.getUidElement());
    if (json.has("sopClass"))
      res.setSopClassElement(parseOid(json.get("sopClass").getAsString()));
    if (json.has("_sopClass"))
      parseElementProperties(json.getAsJsonObject("_sopClass"), res.getSopClassElement());
    if (json.has("type"))
      res.setTypeElement(parseString(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("content")) {
      JsonArray array = json.getAsJsonArray("content");
      for (int i = 0; i < array.size(); i++) {
        res.getContent().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Immunization parseImmunization(JsonObject json) throws IOException, FHIRFormatError {
    Immunization res = new Immunization();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseCode(json.get("status").getAsString()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("vaccineCode"))
      res.setVaccineCode(parseCodeableConcept(json.getAsJsonObject("vaccineCode")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("wasNotGiven"))
      res.setWasNotGivenElement(parseBoolean(json.get("wasNotGiven").getAsBoolean()));
    if (json.has("_wasNotGiven"))
      parseElementProperties(json.getAsJsonObject("_wasNotGiven"), res.getWasNotGivenElement());
    if (json.has("reported"))
      res.setReportedElement(parseBoolean(json.get("reported").getAsBoolean()));
    if (json.has("_reported"))
      parseElementProperties(json.getAsJsonObject("_reported"), res.getReportedElement());
    if (json.has("performer"))
      res.setPerformer(parseReference(json.getAsJsonObject("performer")));
    if (json.has("requester"))
      res.setRequester(parseReference(json.getAsJsonObject("requester")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("manufacturer"))
      res.setManufacturer(parseReference(json.getAsJsonObject("manufacturer")));
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("lotNumber"))
      res.setLotNumberElement(parseString(json.get("lotNumber").getAsString()));
    if (json.has("_lotNumber"))
      parseElementProperties(json.getAsJsonObject("_lotNumber"), res.getLotNumberElement());
    if (json.has("expirationDate"))
      res.setExpirationDateElement(parseDate(json.get("expirationDate").getAsString()));
    if (json.has("_expirationDate"))
      parseElementProperties(json.getAsJsonObject("_expirationDate"), res.getExpirationDateElement());
    if (json.has("site"))
      res.setSite(parseCodeableConcept(json.getAsJsonObject("site")));
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(json.getAsJsonObject("route")));
    if (json.has("doseQuantity"))
      res.setDoseQuantity(parseSimpleQuantity(json.getAsJsonObject("doseQuantity")));
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("explanation"))
      res.setExplanation(parseImmunizationImmunizationExplanationComponent(json.getAsJsonObject("explanation"), res));
    if (json.has("reaction")) {
      JsonArray array = json.getAsJsonArray("reaction");
      for (int i = 0; i < array.size(); i++) {
        res.getReaction().add(parseImmunizationImmunizationReactionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("vaccinationProtocol")) {
      JsonArray array = json.getAsJsonArray("vaccinationProtocol");
      for (int i = 0; i < array.size(); i++) {
        res.getVaccinationProtocol()
            .add(parseImmunizationImmunizationVaccinationProtocolComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Immunization.ImmunizationExplanationComponent parseImmunizationImmunizationExplanationComponent(
      JsonObject json, Immunization owner) throws IOException, FHIRFormatError {
    Immunization.ImmunizationExplanationComponent res = new Immunization.ImmunizationExplanationComponent();
    parseBackboneProperties(json, res);
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reasonNotGiven")) {
      JsonArray array = json.getAsJsonArray("reasonNotGiven");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonNotGiven().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Immunization.ImmunizationReactionComponent parseImmunizationImmunizationReactionComponent(JsonObject json,
      Immunization owner) throws IOException, FHIRFormatError {
    Immunization.ImmunizationReactionComponent res = new Immunization.ImmunizationReactionComponent();
    parseBackboneProperties(json, res);
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("detail"))
      res.setDetail(parseReference(json.getAsJsonObject("detail")));
    if (json.has("reported"))
      res.setReportedElement(parseBoolean(json.get("reported").getAsBoolean()));
    if (json.has("_reported"))
      parseElementProperties(json.getAsJsonObject("_reported"), res.getReportedElement());
    return res;
  }

  protected Immunization.ImmunizationVaccinationProtocolComponent parseImmunizationImmunizationVaccinationProtocolComponent(
      JsonObject json, Immunization owner) throws IOException, FHIRFormatError {
    Immunization.ImmunizationVaccinationProtocolComponent res = new Immunization.ImmunizationVaccinationProtocolComponent();
    parseBackboneProperties(json, res);
    if (json.has("doseSequence"))
      res.setDoseSequenceElement(parsePositiveInt(json.get("doseSequence").getAsString()));
    if (json.has("_doseSequence"))
      parseElementProperties(json.getAsJsonObject("_doseSequence"), res.getDoseSequenceElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("authority"))
      res.setAuthority(parseReference(json.getAsJsonObject("authority")));
    if (json.has("series"))
      res.setSeriesElement(parseString(json.get("series").getAsString()));
    if (json.has("_series"))
      parseElementProperties(json.getAsJsonObject("_series"), res.getSeriesElement());
    if (json.has("seriesDoses"))
      res.setSeriesDosesElement(parsePositiveInt(json.get("seriesDoses").getAsString()));
    if (json.has("_seriesDoses"))
      parseElementProperties(json.getAsJsonObject("_seriesDoses"), res.getSeriesDosesElement());
    if (json.has("targetDisease")) {
      JsonArray array = json.getAsJsonArray("targetDisease");
      for (int i = 0; i < array.size(); i++) {
        res.getTargetDisease().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("doseStatus"))
      res.setDoseStatus(parseCodeableConcept(json.getAsJsonObject("doseStatus")));
    if (json.has("doseStatusReason"))
      res.setDoseStatusReason(parseCodeableConcept(json.getAsJsonObject("doseStatusReason")));
    return res;
  }

  protected ImmunizationRecommendation parseImmunizationRecommendation(JsonObject json)
      throws IOException, FHIRFormatError {
    ImmunizationRecommendation res = new ImmunizationRecommendation();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("recommendation")) {
      JsonArray array = json.getAsJsonArray("recommendation");
      for (int i = 0; i < array.size(); i++) {
        res.getRecommendation().add(parseImmunizationRecommendationImmunizationRecommendationRecommendationComponent(
            array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationComponent(
      JsonObject json, ImmunizationRecommendation owner) throws IOException, FHIRFormatError {
    ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent();
    parseBackboneProperties(json, res);
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("vaccineCode"))
      res.setVaccineCode(parseCodeableConcept(json.getAsJsonObject("vaccineCode")));
    if (json.has("doseNumber"))
      res.setDoseNumberElement(parsePositiveInt(json.get("doseNumber").getAsString()));
    if (json.has("_doseNumber"))
      parseElementProperties(json.getAsJsonObject("_doseNumber"), res.getDoseNumberElement());
    if (json.has("forecastStatus"))
      res.setForecastStatus(parseCodeableConcept(json.getAsJsonObject("forecastStatus")));
    if (json.has("dateCriterion")) {
      JsonArray array = json.getAsJsonArray("dateCriterion");
      for (int i = 0; i < array.size(); i++) {
        res.getDateCriterion()
            .add(parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(
                array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("protocol"))
      res.setProtocol(parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(
          json.getAsJsonObject("protocol"), owner));
    if (json.has("supportingImmunization")) {
      JsonArray array = json.getAsJsonArray("supportingImmunization");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingImmunization().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("supportingPatientInformation")) {
      JsonArray array = json.getAsJsonArray("supportingPatientInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingPatientInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(
      JsonObject json, ImmunizationRecommendation owner) throws IOException, FHIRFormatError {
    ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("value"))
      res.setValueElement(parseDateTime(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(
      JsonObject json, ImmunizationRecommendation owner) throws IOException, FHIRFormatError {
    ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent();
    parseBackboneProperties(json, res);
    if (json.has("doseSequence"))
      res.setDoseSequenceElement(parseInteger(json.get("doseSequence").getAsLong()));
    if (json.has("_doseSequence"))
      parseElementProperties(json.getAsJsonObject("_doseSequence"), res.getDoseSequenceElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("authority"))
      res.setAuthority(parseReference(json.getAsJsonObject("authority")));
    if (json.has("series"))
      res.setSeriesElement(parseString(json.get("series").getAsString()));
    if (json.has("_series"))
      parseElementProperties(json.getAsJsonObject("_series"), res.getSeriesElement());
    return res;
  }

  protected ImplementationGuide parseImplementationGuide(JsonObject json) throws IOException, FHIRFormatError {
    ImplementationGuide res = new ImplementationGuide();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact()
            .add(parseImplementationGuideImplementationGuideContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("fhirVersion"))
      res.setFhirVersionElement(parseId(json.get("fhirVersion").getAsString()));
    if (json.has("_fhirVersion"))
      parseElementProperties(json.getAsJsonObject("_fhirVersion"), res.getFhirVersionElement());
    if (json.has("dependency")) {
      JsonArray array = json.getAsJsonArray("dependency");
      for (int i = 0; i < array.size(); i++) {
        res.getDependency()
            .add(parseImplementationGuideImplementationGuideDependencyComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("package")) {
      JsonArray array = json.getAsJsonArray("package");
      for (int i = 0; i < array.size(); i++) {
        res.getPackage()
            .add(parseImplementationGuideImplementationGuidePackageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("global")) {
      JsonArray array = json.getAsJsonArray("global");
      for (int i = 0; i < array.size(); i++) {
        res.getGlobal()
            .add(parseImplementationGuideImplementationGuideGlobalComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("binary")) {
      JsonArray array = json.getAsJsonArray("binary");
      for (int i = 0; i < array.size(); i++) {
        res.getBinary().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_binary")) {
      JsonArray array = json.getAsJsonArray("_binary");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getBinary().size())
          res.getBinary().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getBinary().get(i));
      }
    }
    ;
    if (json.has("page"))
      res.setPage(parseImplementationGuideImplementationGuidePageComponent(json.getAsJsonObject("page"), res));
    return res;
  }

  protected ImplementationGuide.ImplementationGuideContactComponent parseImplementationGuideImplementationGuideContactComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuideContactComponent res = new ImplementationGuide.ImplementationGuideContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ImplementationGuide.ImplementationGuideDependencyComponent parseImplementationGuideImplementationGuideDependencyComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuideDependencyComponent res = new ImplementationGuide.ImplementationGuideDependencyComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), ImplementationGuide.GuideDependencyType.NULL,
          new ImplementationGuide.GuideDependencyTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("uri"))
      res.setUriElement(parseUri(json.get("uri").getAsString()));
    if (json.has("_uri"))
      parseElementProperties(json.getAsJsonObject("_uri"), res.getUriElement());
    return res;
  }

  protected ImplementationGuide.ImplementationGuidePackageComponent parseImplementationGuideImplementationGuidePackageComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuidePackageComponent res = new ImplementationGuide.ImplementationGuidePackageComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("resource")) {
      JsonArray array = json.getAsJsonArray("resource");
      for (int i = 0; i < array.size(); i++) {
        res.getResource().add(
            parseImplementationGuideImplementationGuidePackageResourceComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ImplementationGuide.ImplementationGuidePackageResourceComponent parseImplementationGuideImplementationGuidePackageResourceComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuidePackageResourceComponent res = new ImplementationGuide.ImplementationGuidePackageResourceComponent();
    parseBackboneProperties(json, res);
    if (json.has("purpose"))
      res.setPurposeElement(parseEnumeration(json.get("purpose").getAsString(),
          ImplementationGuide.GuideResourcePurpose.NULL, new ImplementationGuide.GuideResourcePurposeEnumFactory()));
    if (json.has("_purpose"))
      parseElementProperties(json.getAsJsonObject("_purpose"), res.getPurposeElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("acronym"))
      res.setAcronymElement(parseString(json.get("acronym").getAsString()));
    if (json.has("_acronym"))
      parseElementProperties(json.getAsJsonObject("_acronym"), res.getAcronymElement());
    Type source = parseType("source", json);
    if (source != null)
      res.setSource(source);
    if (json.has("exampleFor"))
      res.setExampleFor(parseReference(json.getAsJsonObject("exampleFor")));
    return res;
  }

  protected ImplementationGuide.ImplementationGuideGlobalComponent parseImplementationGuideImplementationGuideGlobalComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuideGlobalComponent res = new ImplementationGuide.ImplementationGuideGlobalComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseCode(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("profile"))
      res.setProfile(parseReference(json.getAsJsonObject("profile")));
    return res;
  }

  protected ImplementationGuide.ImplementationGuidePageComponent parseImplementationGuideImplementationGuidePageComponent(
      JsonObject json, ImplementationGuide owner) throws IOException, FHIRFormatError {
    ImplementationGuide.ImplementationGuidePageComponent res = new ImplementationGuide.ImplementationGuidePageComponent();
    parseBackboneProperties(json, res);
    if (json.has("source"))
      res.setSourceElement(parseUri(json.get("source").getAsString()));
    if (json.has("_source"))
      parseElementProperties(json.getAsJsonObject("_source"), res.getSourceElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), ImplementationGuide.GuidePageKind.NULL,
          new ImplementationGuide.GuidePageKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(json.getAsJsonObject("_kind"), res.getKindElement());
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_type")) {
      JsonArray array = json.getAsJsonArray("_type");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getType().size())
          res.getType().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getType().get(i));
      }
    }
    ;
    if (json.has("package")) {
      JsonArray array = json.getAsJsonArray("package");
      for (int i = 0; i < array.size(); i++) {
        res.getPackage().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_package")) {
      JsonArray array = json.getAsJsonArray("_package");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPackage().size())
          res.getPackage().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPackage().get(i));
      }
    }
    ;
    if (json.has("format"))
      res.setFormatElement(parseCode(json.get("format").getAsString()));
    if (json.has("_format"))
      parseElementProperties(json.getAsJsonObject("_format"), res.getFormatElement());
    if (json.has("page")) {
      JsonArray array = json.getAsJsonArray("page");
      for (int i = 0; i < array.size(); i++) {
        res.getPage()
            .add(parseImplementationGuideImplementationGuidePageComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected List_ parseList_(JsonObject json) throws IOException, FHIRFormatError {
    List_ res = new List_();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), List_.ListStatus.NULL, new List_.ListStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("orderedBy"))
      res.setOrderedBy(parseCodeableConcept(json.getAsJsonObject("orderedBy")));
    if (json.has("mode"))
      res.setModeElement(
          parseEnumeration(json.get("mode").getAsString(), List_.ListMode.NULL, new List_.ListModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("note"))
      res.setNoteElement(parseString(json.get("note").getAsString()));
    if (json.has("_note"))
      parseElementProperties(json.getAsJsonObject("_note"), res.getNoteElement());
    if (json.has("entry")) {
      JsonArray array = json.getAsJsonArray("entry");
      for (int i = 0; i < array.size(); i++) {
        res.getEntry().add(parseList_ListEntryComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("emptyReason"))
      res.setEmptyReason(parseCodeableConcept(json.getAsJsonObject("emptyReason")));
    return res;
  }

  protected List_.ListEntryComponent parseList_ListEntryComponent(JsonObject json, List_ owner)
      throws IOException, FHIRFormatError {
    List_.ListEntryComponent res = new List_.ListEntryComponent();
    parseBackboneProperties(json, res);
    if (json.has("flag"))
      res.setFlag(parseCodeableConcept(json.getAsJsonObject("flag")));
    if (json.has("deleted"))
      res.setDeletedElement(parseBoolean(json.get("deleted").getAsBoolean()));
    if (json.has("_deleted"))
      parseElementProperties(json.getAsJsonObject("_deleted"), res.getDeletedElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("item"))
      res.setItem(parseReference(json.getAsJsonObject("item")));
    return res;
  }

  protected Location parseLocation(JsonObject json) throws IOException, FHIRFormatError {
    Location res = new Location();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Location.LocationStatus.NULL,
          new Location.LocationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Location.LocationMode.NULL,
          new Location.LocationModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(json.getAsJsonObject("_mode"), res.getModeElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("address"))
      res.setAddress(parseAddress(json.getAsJsonObject("address")));
    if (json.has("physicalType"))
      res.setPhysicalType(parseCodeableConcept(json.getAsJsonObject("physicalType")));
    if (json.has("position"))
      res.setPosition(parseLocationLocationPositionComponent(json.getAsJsonObject("position"), res));
    if (json.has("managingOrganization"))
      res.setManagingOrganization(parseReference(json.getAsJsonObject("managingOrganization")));
    if (json.has("partOf"))
      res.setPartOf(parseReference(json.getAsJsonObject("partOf")));
    return res;
  }

  protected Location.LocationPositionComponent parseLocationLocationPositionComponent(JsonObject json, Location owner)
      throws IOException, FHIRFormatError {
    Location.LocationPositionComponent res = new Location.LocationPositionComponent();
    parseBackboneProperties(json, res);
    if (json.has("longitude"))
      res.setLongitudeElement(parseDecimal(json.get("longitude").getAsBigDecimal()));
    if (json.has("_longitude"))
      parseElementProperties(json.getAsJsonObject("_longitude"), res.getLongitudeElement());
    if (json.has("latitude"))
      res.setLatitudeElement(parseDecimal(json.get("latitude").getAsBigDecimal()));
    if (json.has("_latitude"))
      parseElementProperties(json.getAsJsonObject("_latitude"), res.getLatitudeElement());
    if (json.has("altitude"))
      res.setAltitudeElement(parseDecimal(json.get("altitude").getAsBigDecimal()));
    if (json.has("_altitude"))
      parseElementProperties(json.getAsJsonObject("_altitude"), res.getAltitudeElement());
    return res;
  }

  protected Media parseMedia(JsonObject json) throws IOException, FHIRFormatError {
    Media res = new Media();
    parseDomainResourceProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Media.DigitalMediaType.NULL,
          new Media.DigitalMediaTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("subtype"))
      res.setSubtype(parseCodeableConcept(json.getAsJsonObject("subtype")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("operator"))
      res.setOperator(parseReference(json.getAsJsonObject("operator")));
    if (json.has("view"))
      res.setView(parseCodeableConcept(json.getAsJsonObject("view")));
    if (json.has("deviceName"))
      res.setDeviceNameElement(parseString(json.get("deviceName").getAsString()));
    if (json.has("_deviceName"))
      parseElementProperties(json.getAsJsonObject("_deviceName"), res.getDeviceNameElement());
    if (json.has("height"))
      res.setHeightElement(parsePositiveInt(json.get("height").getAsString()));
    if (json.has("_height"))
      parseElementProperties(json.getAsJsonObject("_height"), res.getHeightElement());
    if (json.has("width"))
      res.setWidthElement(parsePositiveInt(json.get("width").getAsString()));
    if (json.has("_width"))
      parseElementProperties(json.getAsJsonObject("_width"), res.getWidthElement());
    if (json.has("frames"))
      res.setFramesElement(parsePositiveInt(json.get("frames").getAsString()));
    if (json.has("_frames"))
      parseElementProperties(json.getAsJsonObject("_frames"), res.getFramesElement());
    if (json.has("duration"))
      res.setDurationElement(parseUnsignedInt(json.get("duration").getAsString()));
    if (json.has("_duration"))
      parseElementProperties(json.getAsJsonObject("_duration"), res.getDurationElement());
    if (json.has("content"))
      res.setContent(parseAttachment(json.getAsJsonObject("content")));
    return res;
  }

  protected Medication parseMedication(JsonObject json) throws IOException, FHIRFormatError {
    Medication res = new Medication();
    parseDomainResourceProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("isBrand"))
      res.setIsBrandElement(parseBoolean(json.get("isBrand").getAsBoolean()));
    if (json.has("_isBrand"))
      parseElementProperties(json.getAsJsonObject("_isBrand"), res.getIsBrandElement());
    if (json.has("manufacturer"))
      res.setManufacturer(parseReference(json.getAsJsonObject("manufacturer")));
    if (json.has("product"))
      res.setProduct(parseMedicationMedicationProductComponent(json.getAsJsonObject("product"), res));
    if (json.has("package"))
      res.setPackage(parseMedicationMedicationPackageComponent(json.getAsJsonObject("package"), res));
    return res;
  }

  protected Medication.MedicationProductComponent parseMedicationMedicationProductComponent(JsonObject json,
      Medication owner) throws IOException, FHIRFormatError {
    Medication.MedicationProductComponent res = new Medication.MedicationProductComponent();
    parseBackboneProperties(json, res);
    if (json.has("form"))
      res.setForm(parseCodeableConcept(json.getAsJsonObject("form")));
    if (json.has("ingredient")) {
      JsonArray array = json.getAsJsonArray("ingredient");
      for (int i = 0; i < array.size(); i++) {
        res.getIngredient()
            .add(parseMedicationMedicationProductIngredientComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("batch")) {
      JsonArray array = json.getAsJsonArray("batch");
      for (int i = 0; i < array.size(); i++) {
        res.getBatch().add(parseMedicationMedicationProductBatchComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Medication.MedicationProductIngredientComponent parseMedicationMedicationProductIngredientComponent(
      JsonObject json, Medication owner) throws IOException, FHIRFormatError {
    Medication.MedicationProductIngredientComponent res = new Medication.MedicationProductIngredientComponent();
    parseBackboneProperties(json, res);
    if (json.has("item"))
      res.setItem(parseReference(json.getAsJsonObject("item")));
    if (json.has("amount"))
      res.setAmount(parseRatio(json.getAsJsonObject("amount")));
    return res;
  }

  protected Medication.MedicationProductBatchComponent parseMedicationMedicationProductBatchComponent(JsonObject json,
      Medication owner) throws IOException, FHIRFormatError {
    Medication.MedicationProductBatchComponent res = new Medication.MedicationProductBatchComponent();
    parseBackboneProperties(json, res);
    if (json.has("lotNumber"))
      res.setLotNumberElement(parseString(json.get("lotNumber").getAsString()));
    if (json.has("_lotNumber"))
      parseElementProperties(json.getAsJsonObject("_lotNumber"), res.getLotNumberElement());
    if (json.has("expirationDate"))
      res.setExpirationDateElement(parseDateTime(json.get("expirationDate").getAsString()));
    if (json.has("_expirationDate"))
      parseElementProperties(json.getAsJsonObject("_expirationDate"), res.getExpirationDateElement());
    return res;
  }

  protected Medication.MedicationPackageComponent parseMedicationMedicationPackageComponent(JsonObject json,
      Medication owner) throws IOException, FHIRFormatError {
    Medication.MedicationPackageComponent res = new Medication.MedicationPackageComponent();
    parseBackboneProperties(json, res);
    if (json.has("container"))
      res.setContainer(parseCodeableConcept(json.getAsJsonObject("container")));
    if (json.has("content")) {
      JsonArray array = json.getAsJsonArray("content");
      for (int i = 0; i < array.size(); i++) {
        res.getContent().add(parseMedicationMedicationPackageContentComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Medication.MedicationPackageContentComponent parseMedicationMedicationPackageContentComponent(
      JsonObject json, Medication owner) throws IOException, FHIRFormatError {
    Medication.MedicationPackageContentComponent res = new Medication.MedicationPackageContentComponent();
    parseBackboneProperties(json, res);
    if (json.has("item"))
      res.setItem(parseReference(json.getAsJsonObject("item")));
    if (json.has("amount"))
      res.setAmount(parseSimpleQuantity(json.getAsJsonObject("amount")));
    return res;
  }

  protected MedicationAdministration parseMedicationAdministration(JsonObject json)
      throws IOException, FHIRFormatError {
    MedicationAdministration res = new MedicationAdministration();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          MedicationAdministration.MedicationAdministrationStatus.NULL,
          new MedicationAdministration.MedicationAdministrationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("practitioner"))
      res.setPractitioner(parseReference(json.getAsJsonObject("practitioner")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("prescription"))
      res.setPrescription(parseReference(json.getAsJsonObject("prescription")));
    if (json.has("wasNotGiven"))
      res.setWasNotGivenElement(parseBoolean(json.get("wasNotGiven").getAsBoolean()));
    if (json.has("_wasNotGiven"))
      parseElementProperties(json.getAsJsonObject("_wasNotGiven"), res.getWasNotGivenElement());
    if (json.has("reasonNotGiven")) {
      JsonArray array = json.getAsJsonArray("reasonNotGiven");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonNotGiven().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reasonGiven")) {
      JsonArray array = json.getAsJsonArray("reasonGiven");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonGiven().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type effectiveTime = parseType("effectiveTime", json);
    if (effectiveTime != null)
      res.setEffectiveTime(effectiveTime);
    Type medication = parseType("medication", json);
    if (medication != null)
      res.setMedication(medication);
    if (json.has("device")) {
      JsonArray array = json.getAsJsonArray("device");
      for (int i = 0; i < array.size(); i++) {
        res.getDevice().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("note"))
      res.setNoteElement(parseString(json.get("note").getAsString()));
    if (json.has("_note"))
      parseElementProperties(json.getAsJsonObject("_note"), res.getNoteElement());
    if (json.has("dosage"))
      res.setDosage(
          parseMedicationAdministrationMedicationAdministrationDosageComponent(json.getAsJsonObject("dosage"), res));
    return res;
  }

  protected MedicationAdministration.MedicationAdministrationDosageComponent parseMedicationAdministrationMedicationAdministrationDosageComponent(
      JsonObject json, MedicationAdministration owner) throws IOException, FHIRFormatError {
    MedicationAdministration.MedicationAdministrationDosageComponent res = new MedicationAdministration.MedicationAdministrationDosageComponent();
    parseBackboneProperties(json, res);
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    Type site = parseType("site", json);
    if (site != null)
      res.setSite(site);
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(json.getAsJsonObject("route")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    Type rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
    return res;
  }

  protected MedicationDispense parseMedicationDispense(JsonObject json) throws IOException, FHIRFormatError {
    MedicationDispense res = new MedicationDispense();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), MedicationDispense.MedicationDispenseStatus.NULL,
              new MedicationDispense.MedicationDispenseStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("dispenser"))
      res.setDispenser(parseReference(json.getAsJsonObject("dispenser")));
    if (json.has("authorizingPrescription")) {
      JsonArray array = json.getAsJsonArray("authorizingPrescription");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthorizingPrescription().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("daysSupply"))
      res.setDaysSupply(parseSimpleQuantity(json.getAsJsonObject("daysSupply")));
    Type medication = parseType("medication", json);
    if (medication != null)
      res.setMedication(medication);
    if (json.has("whenPrepared"))
      res.setWhenPreparedElement(parseDateTime(json.get("whenPrepared").getAsString()));
    if (json.has("_whenPrepared"))
      parseElementProperties(json.getAsJsonObject("_whenPrepared"), res.getWhenPreparedElement());
    if (json.has("whenHandedOver"))
      res.setWhenHandedOverElement(parseDateTime(json.get("whenHandedOver").getAsString()));
    if (json.has("_whenHandedOver"))
      parseElementProperties(json.getAsJsonObject("_whenHandedOver"), res.getWhenHandedOverElement());
    if (json.has("destination"))
      res.setDestination(parseReference(json.getAsJsonObject("destination")));
    if (json.has("receiver")) {
      JsonArray array = json.getAsJsonArray("receiver");
      for (int i = 0; i < array.size(); i++) {
        res.getReceiver().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("note"))
      res.setNoteElement(parseString(json.get("note").getAsString()));
    if (json.has("_note"))
      parseElementProperties(json.getAsJsonObject("_note"), res.getNoteElement());
    if (json.has("dosageInstruction")) {
      JsonArray array = json.getAsJsonArray("dosageInstruction");
      for (int i = 0; i < array.size(); i++) {
        res.getDosageInstruction().add(
            parseMedicationDispenseMedicationDispenseDosageInstructionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("substitution"))
      res.setSubstitution(
          parseMedicationDispenseMedicationDispenseSubstitutionComponent(json.getAsJsonObject("substitution"), res));
    return res;
  }

  protected MedicationDispense.MedicationDispenseDosageInstructionComponent parseMedicationDispenseMedicationDispenseDosageInstructionComponent(
      JsonObject json, MedicationDispense owner) throws IOException, FHIRFormatError {
    MedicationDispense.MedicationDispenseDosageInstructionComponent res = new MedicationDispense.MedicationDispenseDosageInstructionComponent();
    parseBackboneProperties(json, res);
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("additionalInstructions"))
      res.setAdditionalInstructions(parseCodeableConcept(json.getAsJsonObject("additionalInstructions")));
    if (json.has("timing"))
      res.setTiming(parseTiming(json.getAsJsonObject("timing")));
    Type asNeeded = parseType("asNeeded", json);
    if (asNeeded != null)
      res.setAsNeeded(asNeeded);
    Type site = parseType("site", json);
    if (site != null)
      res.setSite(site);
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(json.getAsJsonObject("route")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    Type dose = parseType("dose", json);
    if (dose != null)
      res.setDose(dose);
    Type rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
    if (json.has("maxDosePerPeriod"))
      res.setMaxDosePerPeriod(parseRatio(json.getAsJsonObject("maxDosePerPeriod")));
    return res;
  }

  protected MedicationDispense.MedicationDispenseSubstitutionComponent parseMedicationDispenseMedicationDispenseSubstitutionComponent(
      JsonObject json, MedicationDispense owner) throws IOException, FHIRFormatError {
    MedicationDispense.MedicationDispenseSubstitutionComponent res = new MedicationDispense.MedicationDispenseSubstitutionComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("responsibleParty")) {
      JsonArray array = json.getAsJsonArray("responsibleParty");
      for (int i = 0; i < array.size(); i++) {
        res.getResponsibleParty().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected MedicationOrder parseMedicationOrder(JsonObject json) throws IOException, FHIRFormatError {
    MedicationOrder res = new MedicationOrder();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("dateWritten"))
      res.setDateWrittenElement(parseDateTime(json.get("dateWritten").getAsString()));
    if (json.has("_dateWritten"))
      parseElementProperties(json.getAsJsonObject("_dateWritten"), res.getDateWrittenElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          MedicationOrder.MedicationOrderStatus.NULL, new MedicationOrder.MedicationOrderStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("dateEnded"))
      res.setDateEndedElement(parseDateTime(json.get("dateEnded").getAsString()));
    if (json.has("_dateEnded"))
      parseElementProperties(json.getAsJsonObject("_dateEnded"), res.getDateEndedElement());
    if (json.has("reasonEnded"))
      res.setReasonEnded(parseCodeableConcept(json.getAsJsonObject("reasonEnded")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("prescriber"))
      res.setPrescriber(parseReference(json.getAsJsonObject("prescriber")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    if (json.has("note"))
      res.setNoteElement(parseString(json.get("note").getAsString()));
    if (json.has("_note"))
      parseElementProperties(json.getAsJsonObject("_note"), res.getNoteElement());
    Type medication = parseType("medication", json);
    if (medication != null)
      res.setMedication(medication);
    if (json.has("dosageInstruction")) {
      JsonArray array = json.getAsJsonArray("dosageInstruction");
      for (int i = 0; i < array.size(); i++) {
        res.getDosageInstruction()
            .add(parseMedicationOrderMedicationOrderDosageInstructionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("dispenseRequest"))
      res.setDispenseRequest(
          parseMedicationOrderMedicationOrderDispenseRequestComponent(json.getAsJsonObject("dispenseRequest"), res));
    if (json.has("substitution"))
      res.setSubstitution(
          parseMedicationOrderMedicationOrderSubstitutionComponent(json.getAsJsonObject("substitution"), res));
    if (json.has("priorPrescription"))
      res.setPriorPrescription(parseReference(json.getAsJsonObject("priorPrescription")));
    return res;
  }

  protected MedicationOrder.MedicationOrderDosageInstructionComponent parseMedicationOrderMedicationOrderDosageInstructionComponent(
      JsonObject json, MedicationOrder owner) throws IOException, FHIRFormatError {
    MedicationOrder.MedicationOrderDosageInstructionComponent res = new MedicationOrder.MedicationOrderDosageInstructionComponent();
    parseBackboneProperties(json, res);
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("additionalInstructions"))
      res.setAdditionalInstructions(parseCodeableConcept(json.getAsJsonObject("additionalInstructions")));
    if (json.has("timing"))
      res.setTiming(parseTiming(json.getAsJsonObject("timing")));
    Type asNeeded = parseType("asNeeded", json);
    if (asNeeded != null)
      res.setAsNeeded(asNeeded);
    Type site = parseType("site", json);
    if (site != null)
      res.setSite(site);
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(json.getAsJsonObject("route")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    Type dose = parseType("dose", json);
    if (dose != null)
      res.setDose(dose);
    Type rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
    if (json.has("maxDosePerPeriod"))
      res.setMaxDosePerPeriod(parseRatio(json.getAsJsonObject("maxDosePerPeriod")));
    return res;
  }

  protected MedicationOrder.MedicationOrderDispenseRequestComponent parseMedicationOrderMedicationOrderDispenseRequestComponent(
      JsonObject json, MedicationOrder owner) throws IOException, FHIRFormatError {
    MedicationOrder.MedicationOrderDispenseRequestComponent res = new MedicationOrder.MedicationOrderDispenseRequestComponent();
    parseBackboneProperties(json, res);
    Type medication = parseType("medication", json);
    if (medication != null)
      res.setMedication(medication);
    if (json.has("validityPeriod"))
      res.setValidityPeriod(parsePeriod(json.getAsJsonObject("validityPeriod")));
    if (json.has("numberOfRepeatsAllowed"))
      res.setNumberOfRepeatsAllowedElement(parsePositiveInt(json.get("numberOfRepeatsAllowed").getAsString()));
    if (json.has("_numberOfRepeatsAllowed"))
      parseElementProperties(json.getAsJsonObject("_numberOfRepeatsAllowed"), res.getNumberOfRepeatsAllowedElement());
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("expectedSupplyDuration"))
      res.setExpectedSupplyDuration(parseDuration(json.getAsJsonObject("expectedSupplyDuration")));
    return res;
  }

  protected MedicationOrder.MedicationOrderSubstitutionComponent parseMedicationOrderMedicationOrderSubstitutionComponent(
      JsonObject json, MedicationOrder owner) throws IOException, FHIRFormatError {
    MedicationOrder.MedicationOrderSubstitutionComponent res = new MedicationOrder.MedicationOrderSubstitutionComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(json.getAsJsonObject("reason")));
    return res;
  }

  protected MedicationStatement parseMedicationStatement(JsonObject json) throws IOException, FHIRFormatError {
    MedicationStatement res = new MedicationStatement();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("informationSource"))
      res.setInformationSource(parseReference(json.getAsJsonObject("informationSource")));
    if (json.has("dateAsserted"))
      res.setDateAssertedElement(parseDateTime(json.get("dateAsserted").getAsString()));
    if (json.has("_dateAsserted"))
      parseElementProperties(json.getAsJsonObject("_dateAsserted"), res.getDateAssertedElement());
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), MedicationStatement.MedicationStatementStatus.NULL,
              new MedicationStatement.MedicationStatementStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("wasNotTaken"))
      res.setWasNotTakenElement(parseBoolean(json.get("wasNotTaken").getAsBoolean()));
    if (json.has("_wasNotTaken"))
      parseElementProperties(json.getAsJsonObject("_wasNotTaken"), res.getWasNotTakenElement());
    if (json.has("reasonNotTaken")) {
      JsonArray array = json.getAsJsonArray("reasonNotTaken");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonNotTaken().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type reasonForUse = parseType("reasonForUse", json);
    if (reasonForUse != null)
      res.setReasonForUse(reasonForUse);
    Type effective = parseType("effective", json);
    if (effective != null)
      res.setEffective(effective);
    if (json.has("note"))
      res.setNoteElement(parseString(json.get("note").getAsString()));
    if (json.has("_note"))
      parseElementProperties(json.getAsJsonObject("_note"), res.getNoteElement());
    if (json.has("supportingInformation")) {
      JsonArray array = json.getAsJsonArray("supportingInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type medication = parseType("medication", json);
    if (medication != null)
      res.setMedication(medication);
    if (json.has("dosage")) {
      JsonArray array = json.getAsJsonArray("dosage");
      for (int i = 0; i < array.size(); i++) {
        res.getDosage()
            .add(parseMedicationStatementMedicationStatementDosageComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected MedicationStatement.MedicationStatementDosageComponent parseMedicationStatementMedicationStatementDosageComponent(
      JsonObject json, MedicationStatement owner) throws IOException, FHIRFormatError {
    MedicationStatement.MedicationStatementDosageComponent res = new MedicationStatement.MedicationStatementDosageComponent();
    parseBackboneProperties(json, res);
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("timing"))
      res.setTiming(parseTiming(json.getAsJsonObject("timing")));
    Type asNeeded = parseType("asNeeded", json);
    if (asNeeded != null)
      res.setAsNeeded(asNeeded);
    Type site = parseType("site", json);
    if (site != null)
      res.setSite(site);
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(json.getAsJsonObject("route")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    Type quantity = parseType("quantity", json);
    if (quantity != null)
      res.setQuantity(quantity);
    Type rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
    if (json.has("maxDosePerPeriod"))
      res.setMaxDosePerPeriod(parseRatio(json.getAsJsonObject("maxDosePerPeriod")));
    return res;
  }

  protected MessageHeader parseMessageHeader(JsonObject json) throws IOException, FHIRFormatError {
    MessageHeader res = new MessageHeader();
    parseDomainResourceProperties(json, res);
    if (json.has("timestamp"))
      res.setTimestampElement(parseInstant(json.get("timestamp").getAsString()));
    if (json.has("_timestamp"))
      parseElementProperties(json.getAsJsonObject("_timestamp"), res.getTimestampElement());
    if (json.has("event"))
      res.setEvent(parseCoding(json.getAsJsonObject("event")));
    if (json.has("response"))
      res.setResponse(parseMessageHeaderMessageHeaderResponseComponent(json.getAsJsonObject("response"), res));
    if (json.has("source"))
      res.setSource(parseMessageHeaderMessageSourceComponent(json.getAsJsonObject("source"), res));
    if (json.has("destination")) {
      JsonArray array = json.getAsJsonArray("destination");
      for (int i = 0; i < array.size(); i++) {
        res.getDestination().add(parseMessageHeaderMessageDestinationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("enterer"))
      res.setEnterer(parseReference(json.getAsJsonObject("enterer")));
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("receiver"))
      res.setReceiver(parseReference(json.getAsJsonObject("receiver")));
    if (json.has("responsible"))
      res.setResponsible(parseReference(json.getAsJsonObject("responsible")));
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(json.getAsJsonObject("reason")));
    if (json.has("data")) {
      JsonArray array = json.getAsJsonArray("data");
      for (int i = 0; i < array.size(); i++) {
        res.getData().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected MessageHeader.MessageHeaderResponseComponent parseMessageHeaderMessageHeaderResponseComponent(
      JsonObject json, MessageHeader owner) throws IOException, FHIRFormatError {
    MessageHeader.MessageHeaderResponseComponent res = new MessageHeader.MessageHeaderResponseComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifierElement(parseId(json.get("identifier").getAsString()));
    if (json.has("_identifier"))
      parseElementProperties(json.getAsJsonObject("_identifier"), res.getIdentifierElement());
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), MessageHeader.ResponseType.NULL,
          new MessageHeader.ResponseTypeEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("details"))
      res.setDetails(parseReference(json.getAsJsonObject("details")));
    return res;
  }

  protected MessageHeader.MessageSourceComponent parseMessageHeaderMessageSourceComponent(JsonObject json,
      MessageHeader owner) throws IOException, FHIRFormatError {
    MessageHeader.MessageSourceComponent res = new MessageHeader.MessageSourceComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("software"))
      res.setSoftwareElement(parseString(json.get("software").getAsString()));
    if (json.has("_software"))
      parseElementProperties(json.getAsJsonObject("_software"), res.getSoftwareElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("contact"))
      res.setContact(parseContactPoint(json.getAsJsonObject("contact")));
    if (json.has("endpoint"))
      res.setEndpointElement(parseUri(json.get("endpoint").getAsString()));
    if (json.has("_endpoint"))
      parseElementProperties(json.getAsJsonObject("_endpoint"), res.getEndpointElement());
    return res;
  }

  protected MessageHeader.MessageDestinationComponent parseMessageHeaderMessageDestinationComponent(JsonObject json,
      MessageHeader owner) throws IOException, FHIRFormatError {
    MessageHeader.MessageDestinationComponent res = new MessageHeader.MessageDestinationComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("endpoint"))
      res.setEndpointElement(parseUri(json.get("endpoint").getAsString()));
    if (json.has("_endpoint"))
      parseElementProperties(json.getAsJsonObject("_endpoint"), res.getEndpointElement());
    return res;
  }

  protected NamingSystem parseNamingSystem(JsonObject json) throws IOException, FHIRFormatError {
    NamingSystem res = new NamingSystem();
    parseDomainResourceProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), NamingSystem.NamingSystemType.NULL,
          new NamingSystem.NamingSystemTypeEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(json.getAsJsonObject("_kind"), res.getKindElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseNamingSystemNamingSystemContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("responsible"))
      res.setResponsibleElement(parseString(json.get("responsible").getAsString()));
    if (json.has("_responsible"))
      parseElementProperties(json.getAsJsonObject("_responsible"), res.getResponsibleElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("usage"))
      res.setUsageElement(parseString(json.get("usage").getAsString()));
    if (json.has("_usage"))
      parseElementProperties(json.getAsJsonObject("_usage"), res.getUsageElement());
    if (json.has("uniqueId")) {
      JsonArray array = json.getAsJsonArray("uniqueId");
      for (int i = 0; i < array.size(); i++) {
        res.getUniqueId().add(parseNamingSystemNamingSystemUniqueIdComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("replacedBy"))
      res.setReplacedBy(parseReference(json.getAsJsonObject("replacedBy")));
    return res;
  }

  protected NamingSystem.NamingSystemContactComponent parseNamingSystemNamingSystemContactComponent(JsonObject json,
      NamingSystem owner) throws IOException, FHIRFormatError {
    NamingSystem.NamingSystemContactComponent res = new NamingSystem.NamingSystemContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected NamingSystem.NamingSystemUniqueIdComponent parseNamingSystemNamingSystemUniqueIdComponent(JsonObject json,
      NamingSystem owner) throws IOException, FHIRFormatError {
    NamingSystem.NamingSystemUniqueIdComponent res = new NamingSystem.NamingSystemUniqueIdComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), NamingSystem.NamingSystemIdentifierType.NULL,
          new NamingSystem.NamingSystemIdentifierTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("preferred"))
      res.setPreferredElement(parseBoolean(json.get("preferred").getAsBoolean()));
    if (json.has("_preferred"))
      parseElementProperties(json.getAsJsonObject("_preferred"), res.getPreferredElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected NutritionOrder parseNutritionOrder(JsonObject json) throws IOException, FHIRFormatError {
    NutritionOrder res = new NutritionOrder();
    parseDomainResourceProperties(json, res);
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("orderer"))
      res.setOrderer(parseReference(json.getAsJsonObject("orderer")));
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("dateTime"))
      res.setDateTimeElement(parseDateTime(json.get("dateTime").getAsString()));
    if (json.has("_dateTime"))
      parseElementProperties(json.getAsJsonObject("_dateTime"), res.getDateTimeElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), NutritionOrder.NutritionOrderStatus.NULL,
          new NutritionOrder.NutritionOrderStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("allergyIntolerance")) {
      JsonArray array = json.getAsJsonArray("allergyIntolerance");
      for (int i = 0; i < array.size(); i++) {
        res.getAllergyIntolerance().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("foodPreferenceModifier")) {
      JsonArray array = json.getAsJsonArray("foodPreferenceModifier");
      for (int i = 0; i < array.size(); i++) {
        res.getFoodPreferenceModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("excludeFoodModifier")) {
      JsonArray array = json.getAsJsonArray("excludeFoodModifier");
      for (int i = 0; i < array.size(); i++) {
        res.getExcludeFoodModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("oralDiet"))
      res.setOralDiet(parseNutritionOrderNutritionOrderOralDietComponent(json.getAsJsonObject("oralDiet"), res));
    if (json.has("supplement")) {
      JsonArray array = json.getAsJsonArray("supplement");
      for (int i = 0; i < array.size(); i++) {
        res.getSupplement()
            .add(parseNutritionOrderNutritionOrderSupplementComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("enteralFormula"))
      res.setEnteralFormula(
          parseNutritionOrderNutritionOrderEnteralFormulaComponent(json.getAsJsonObject("enteralFormula"), res));
    return res;
  }

  protected NutritionOrder.NutritionOrderOralDietComponent parseNutritionOrderNutritionOrderOralDietComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderOralDietComponent res = new NutritionOrder.NutritionOrderOralDietComponent();
    parseBackboneProperties(json, res);
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("schedule")) {
      JsonArray array = json.getAsJsonArray("schedule");
      for (int i = 0; i < array.size(); i++) {
        res.getSchedule().add(parseTiming(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("nutrient")) {
      JsonArray array = json.getAsJsonArray("nutrient");
      for (int i = 0; i < array.size(); i++) {
        res.getNutrient()
            .add(parseNutritionOrderNutritionOrderOralDietNutrientComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("texture")) {
      JsonArray array = json.getAsJsonArray("texture");
      for (int i = 0; i < array.size(); i++) {
        res.getTexture()
            .add(parseNutritionOrderNutritionOrderOralDietTextureComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("fluidConsistencyType")) {
      JsonArray array = json.getAsJsonArray("fluidConsistencyType");
      for (int i = 0; i < array.size(); i++) {
        res.getFluidConsistencyType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("instruction"))
      res.setInstructionElement(parseString(json.get("instruction").getAsString()));
    if (json.has("_instruction"))
      parseElementProperties(json.getAsJsonObject("_instruction"), res.getInstructionElement());
    return res;
  }

  protected NutritionOrder.NutritionOrderOralDietNutrientComponent parseNutritionOrderNutritionOrderOralDietNutrientComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderOralDietNutrientComponent res = new NutritionOrder.NutritionOrderOralDietNutrientComponent();
    parseBackboneProperties(json, res);
    if (json.has("modifier"))
      res.setModifier(parseCodeableConcept(json.getAsJsonObject("modifier")));
    if (json.has("amount"))
      res.setAmount(parseSimpleQuantity(json.getAsJsonObject("amount")));
    return res;
  }

  protected NutritionOrder.NutritionOrderOralDietTextureComponent parseNutritionOrderNutritionOrderOralDietTextureComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderOralDietTextureComponent res = new NutritionOrder.NutritionOrderOralDietTextureComponent();
    parseBackboneProperties(json, res);
    if (json.has("modifier"))
      res.setModifier(parseCodeableConcept(json.getAsJsonObject("modifier")));
    if (json.has("foodType"))
      res.setFoodType(parseCodeableConcept(json.getAsJsonObject("foodType")));
    return res;
  }

  protected NutritionOrder.NutritionOrderSupplementComponent parseNutritionOrderNutritionOrderSupplementComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderSupplementComponent res = new NutritionOrder.NutritionOrderSupplementComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("productName"))
      res.setProductNameElement(parseString(json.get("productName").getAsString()));
    if (json.has("_productName"))
      parseElementProperties(json.getAsJsonObject("_productName"), res.getProductNameElement());
    if (json.has("schedule")) {
      JsonArray array = json.getAsJsonArray("schedule");
      for (int i = 0; i < array.size(); i++) {
        res.getSchedule().add(parseTiming(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("instruction"))
      res.setInstructionElement(parseString(json.get("instruction").getAsString()));
    if (json.has("_instruction"))
      parseElementProperties(json.getAsJsonObject("_instruction"), res.getInstructionElement());
    return res;
  }

  protected NutritionOrder.NutritionOrderEnteralFormulaComponent parseNutritionOrderNutritionOrderEnteralFormulaComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderEnteralFormulaComponent res = new NutritionOrder.NutritionOrderEnteralFormulaComponent();
    parseBackboneProperties(json, res);
    if (json.has("baseFormulaType"))
      res.setBaseFormulaType(parseCodeableConcept(json.getAsJsonObject("baseFormulaType")));
    if (json.has("baseFormulaProductName"))
      res.setBaseFormulaProductNameElement(parseString(json.get("baseFormulaProductName").getAsString()));
    if (json.has("_baseFormulaProductName"))
      parseElementProperties(json.getAsJsonObject("_baseFormulaProductName"), res.getBaseFormulaProductNameElement());
    if (json.has("additiveType"))
      res.setAdditiveType(parseCodeableConcept(json.getAsJsonObject("additiveType")));
    if (json.has("additiveProductName"))
      res.setAdditiveProductNameElement(parseString(json.get("additiveProductName").getAsString()));
    if (json.has("_additiveProductName"))
      parseElementProperties(json.getAsJsonObject("_additiveProductName"), res.getAdditiveProductNameElement());
    if (json.has("caloricDensity"))
      res.setCaloricDensity(parseSimpleQuantity(json.getAsJsonObject("caloricDensity")));
    if (json.has("routeofAdministration"))
      res.setRouteofAdministration(parseCodeableConcept(json.getAsJsonObject("routeofAdministration")));
    if (json.has("administration")) {
      JsonArray array = json.getAsJsonArray("administration");
      for (int i = 0; i < array.size(); i++) {
        res.getAdministration().add(parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(
            array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("maxVolumeToDeliver"))
      res.setMaxVolumeToDeliver(parseSimpleQuantity(json.getAsJsonObject("maxVolumeToDeliver")));
    if (json.has("administrationInstruction"))
      res.setAdministrationInstructionElement(parseString(json.get("administrationInstruction").getAsString()));
    if (json.has("_administrationInstruction"))
      parseElementProperties(json.getAsJsonObject("_administrationInstruction"),
          res.getAdministrationInstructionElement());
    return res;
  }

  protected NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(
      JsonObject json, NutritionOrder owner) throws IOException, FHIRFormatError {
    NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent res = new NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent();
    parseBackboneProperties(json, res);
    if (json.has("schedule"))
      res.setSchedule(parseTiming(json.getAsJsonObject("schedule")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    Type rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
    return res;
  }

  protected Observation parseObservation(JsonObject json) throws IOException, FHIRFormatError {
    Observation res = new Observation();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Observation.ObservationStatus.NULL,
          new Observation.ObservationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    Type effective = parseType("effective", json);
    if (effective != null)
      res.setEffective(effective);
    if (json.has("issued"))
      res.setIssuedElement(parseInstant(json.get("issued").getAsString()));
    if (json.has("_issued"))
      parseElementProperties(json.getAsJsonObject("_issued"), res.getIssuedElement());
    if (json.has("performer")) {
      JsonArray array = json.getAsJsonArray("performer");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformer().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("dataAbsentReason"))
      res.setDataAbsentReason(parseCodeableConcept(json.getAsJsonObject("dataAbsentReason")));
    if (json.has("interpretation"))
      res.setInterpretation(parseCodeableConcept(json.getAsJsonObject("interpretation")));
    if (json.has("comments"))
      res.setCommentsElement(parseString(json.get("comments").getAsString()));
    if (json.has("_comments"))
      parseElementProperties(json.getAsJsonObject("_comments"), res.getCommentsElement());
    if (json.has("bodySite"))
      res.setBodySite(parseCodeableConcept(json.getAsJsonObject("bodySite")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    if (json.has("specimen"))
      res.setSpecimen(parseReference(json.getAsJsonObject("specimen")));
    if (json.has("device"))
      res.setDevice(parseReference(json.getAsJsonObject("device")));
    if (json.has("referenceRange")) {
      JsonArray array = json.getAsJsonArray("referenceRange");
      for (int i = 0; i < array.size(); i++) {
        res.getReferenceRange()
            .add(parseObservationObservationReferenceRangeComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("related")) {
      JsonArray array = json.getAsJsonArray("related");
      for (int i = 0; i < array.size(); i++) {
        res.getRelated().add(parseObservationObservationRelatedComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("component")) {
      JsonArray array = json.getAsJsonArray("component");
      for (int i = 0; i < array.size(); i++) {
        res.getComponent().add(parseObservationObservationComponentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Observation.ObservationReferenceRangeComponent parseObservationObservationReferenceRangeComponent(
      JsonObject json, Observation owner) throws IOException, FHIRFormatError {
    Observation.ObservationReferenceRangeComponent res = new Observation.ObservationReferenceRangeComponent();
    parseBackboneProperties(json, res);
    if (json.has("low"))
      res.setLow(parseSimpleQuantity(json.getAsJsonObject("low")));
    if (json.has("high"))
      res.setHigh(parseSimpleQuantity(json.getAsJsonObject("high")));
    if (json.has("meaning"))
      res.setMeaning(parseCodeableConcept(json.getAsJsonObject("meaning")));
    if (json.has("age"))
      res.setAge(parseRange(json.getAsJsonObject("age")));
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected Observation.ObservationRelatedComponent parseObservationObservationRelatedComponent(JsonObject json,
      Observation owner) throws IOException, FHIRFormatError {
    Observation.ObservationRelatedComponent res = new Observation.ObservationRelatedComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Observation.ObservationRelationshipType.NULL,
          new Observation.ObservationRelationshipTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    return res;
  }

  protected Observation.ObservationComponentComponent parseObservationObservationComponentComponent(JsonObject json,
      Observation owner) throws IOException, FHIRFormatError {
    Observation.ObservationComponentComponent res = new Observation.ObservationComponentComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("dataAbsentReason"))
      res.setDataAbsentReason(parseCodeableConcept(json.getAsJsonObject("dataAbsentReason")));
    if (json.has("referenceRange")) {
      JsonArray array = json.getAsJsonArray("referenceRange");
      for (int i = 0; i < array.size(); i++) {
        res.getReferenceRange()
            .add(parseObservationObservationReferenceRangeComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected OperationDefinition parseOperationDefinition(JsonObject json) throws IOException, FHIRFormatError {
    OperationDefinition res = new OperationDefinition();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), OperationDefinition.OperationKind.NULL,
          new OperationDefinition.OperationKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(json.getAsJsonObject("_kind"), res.getKindElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact()
            .add(parseOperationDefinitionOperationDefinitionContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("idempotent"))
      res.setIdempotentElement(parseBoolean(json.get("idempotent").getAsBoolean()));
    if (json.has("_idempotent"))
      parseElementProperties(json.getAsJsonObject("_idempotent"), res.getIdempotentElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("notes"))
      res.setNotesElement(parseString(json.get("notes").getAsString()));
    if (json.has("_notes"))
      parseElementProperties(json.getAsJsonObject("_notes"), res.getNotesElement());
    if (json.has("base"))
      res.setBase(parseReference(json.getAsJsonObject("base")));
    if (json.has("system"))
      res.setSystemElement(parseBoolean(json.get("system").getAsBoolean()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_type")) {
      JsonArray array = json.getAsJsonArray("_type");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getType().size())
          res.getType().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getType().get(i));
      }
    }
    ;
    if (json.has("instance"))
      res.setInstanceElement(parseBoolean(json.get("instance").getAsBoolean()));
    if (json.has("_instance"))
      parseElementProperties(json.getAsJsonObject("_instance"), res.getInstanceElement());
    if (json.has("parameter")) {
      JsonArray array = json.getAsJsonArray("parameter");
      for (int i = 0; i < array.size(); i++) {
        res.getParameter()
            .add(parseOperationDefinitionOperationDefinitionParameterComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected OperationDefinition.OperationDefinitionContactComponent parseOperationDefinitionOperationDefinitionContactComponent(
      JsonObject json, OperationDefinition owner) throws IOException, FHIRFormatError {
    OperationDefinition.OperationDefinitionContactComponent res = new OperationDefinition.OperationDefinitionContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected OperationDefinition.OperationDefinitionParameterComponent parseOperationDefinitionOperationDefinitionParameterComponent(
      JsonObject json, OperationDefinition owner) throws IOException, FHIRFormatError {
    OperationDefinition.OperationDefinitionParameterComponent res = new OperationDefinition.OperationDefinitionParameterComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseCode(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), OperationDefinition.OperationParameterUse.NULL,
          new OperationDefinition.OperationParameterUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(json.getAsJsonObject("_use"), res.getUseElement());
    if (json.has("min"))
      res.setMinElement(parseInteger(json.get("min").getAsLong()));
    if (json.has("_min"))
      parseElementProperties(json.getAsJsonObject("_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(json.getAsJsonObject("_max"), res.getMaxElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(json.getAsJsonObject("_documentation"), res.getDocumentationElement());
    if (json.has("type"))
      res.setTypeElement(parseCode(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("profile"))
      res.setProfile(parseReference(json.getAsJsonObject("profile")));
    if (json.has("binding"))
      res.setBinding(
          parseOperationDefinitionOperationDefinitionParameterBindingComponent(json.getAsJsonObject("binding"), owner));
    if (json.has("part")) {
      JsonArray array = json.getAsJsonArray("part");
      for (int i = 0; i < array.size(); i++) {
        res.getPart()
            .add(parseOperationDefinitionOperationDefinitionParameterComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected OperationDefinition.OperationDefinitionParameterBindingComponent parseOperationDefinitionOperationDefinitionParameterBindingComponent(
      JsonObject json, OperationDefinition owner) throws IOException, FHIRFormatError {
    OperationDefinition.OperationDefinitionParameterBindingComponent res = new OperationDefinition.OperationDefinitionParameterBindingComponent();
    parseBackboneProperties(json, res);
    if (json.has("strength"))
      res.setStrengthElement(parseEnumeration(json.get("strength").getAsString(), Enumerations.BindingStrength.NULL,
          new Enumerations.BindingStrengthEnumFactory()));
    if (json.has("_strength"))
      parseElementProperties(json.getAsJsonObject("_strength"), res.getStrengthElement());
    Type valueSet = parseType("valueSet", json);
    if (valueSet != null)
      res.setValueSet(valueSet);
    return res;
  }

  protected OperationOutcome parseOperationOutcome(JsonObject json) throws IOException, FHIRFormatError {
    OperationOutcome res = new OperationOutcome();
    parseDomainResourceProperties(json, res);
    if (json.has("issue")) {
      JsonArray array = json.getAsJsonArray("issue");
      for (int i = 0; i < array.size(); i++) {
        res.getIssue().add(parseOperationOutcomeOperationOutcomeIssueComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected OperationOutcome.OperationOutcomeIssueComponent parseOperationOutcomeOperationOutcomeIssueComponent(
      JsonObject json, OperationOutcome owner) throws IOException, FHIRFormatError {
    OperationOutcome.OperationOutcomeIssueComponent res = new OperationOutcome.OperationOutcomeIssueComponent();
    parseBackboneProperties(json, res);
    if (json.has("severity"))
      res.setSeverityElement(parseEnumeration(json.get("severity").getAsString(), OperationOutcome.IssueSeverity.NULL,
          new OperationOutcome.IssueSeverityEnumFactory()));
    if (json.has("_severity"))
      parseElementProperties(json.getAsJsonObject("_severity"), res.getSeverityElement());
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), OperationOutcome.IssueType.NULL,
          new OperationOutcome.IssueTypeEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("details"))
      res.setDetails(parseCodeableConcept(json.getAsJsonObject("details")));
    if (json.has("diagnostics"))
      res.setDiagnosticsElement(parseString(json.get("diagnostics").getAsString()));
    if (json.has("_diagnostics"))
      parseElementProperties(json.getAsJsonObject("_diagnostics"), res.getDiagnosticsElement());
    if (json.has("location")) {
      JsonArray array = json.getAsJsonArray("location");
      for (int i = 0; i < array.size(); i++) {
        res.getLocation().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_location")) {
      JsonArray array = json.getAsJsonArray("_location");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getLocation().size())
          res.getLocation().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getLocation().get(i));
      }
    }
    ;
    return res;
  }

  protected Order parseOrder(JsonObject json) throws IOException, FHIRFormatError {
    Order res = new Order();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    if (json.has("when"))
      res.setWhen(parseOrderOrderWhenComponent(json.getAsJsonObject("when"), res));
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Order.OrderWhenComponent parseOrderOrderWhenComponent(JsonObject json, Order owner)
      throws IOException, FHIRFormatError {
    Order.OrderWhenComponent res = new Order.OrderWhenComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("schedule"))
      res.setSchedule(parseTiming(json.getAsJsonObject("schedule")));
    return res;
  }

  protected OrderResponse parseOrderResponse(JsonObject json) throws IOException, FHIRFormatError {
    OrderResponse res = new OrderResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("who"))
      res.setWho(parseReference(json.getAsJsonObject("who")));
    if (json.has("orderStatus"))
      res.setOrderStatusElement(parseEnumeration(json.get("orderStatus").getAsString(), OrderResponse.OrderStatus.NULL,
          new OrderResponse.OrderStatusEnumFactory()));
    if (json.has("_orderStatus"))
      parseElementProperties(json.getAsJsonObject("_orderStatus"), res.getOrderStatusElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("fulfillment")) {
      JsonArray array = json.getAsJsonArray("fulfillment");
      for (int i = 0; i < array.size(); i++) {
        res.getFulfillment().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Organization parseOrganization(JsonObject json) throws IOException, FHIRFormatError {
    Organization res = new Organization();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("active"))
      res.setActiveElement(parseBoolean(json.get("active").getAsBoolean()));
    if (json.has("_active"))
      parseElementProperties(json.getAsJsonObject("_active"), res.getActiveElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("address")) {
      JsonArray array = json.getAsJsonArray("address");
      for (int i = 0; i < array.size(); i++) {
        res.getAddress().add(parseAddress(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("partOf"))
      res.setPartOf(parseReference(json.getAsJsonObject("partOf")));
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseOrganizationOrganizationContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Organization.OrganizationContactComponent parseOrganizationOrganizationContactComponent(JsonObject json,
      Organization owner) throws IOException, FHIRFormatError {
    Organization.OrganizationContactComponent res = new Organization.OrganizationContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("purpose"))
      res.setPurpose(parseCodeableConcept(json.getAsJsonObject("purpose")));
    if (json.has("name"))
      res.setName(parseHumanName(json.getAsJsonObject("name")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("address"))
      res.setAddress(parseAddress(json.getAsJsonObject("address")));
    return res;
  }

  protected Patient parsePatient(JsonObject json) throws IOException, FHIRFormatError {
    Patient res = new Patient();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("active"))
      res.setActiveElement(parseBoolean(json.get("active").getAsBoolean()));
    if (json.has("_active"))
      parseElementProperties(json.getAsJsonObject("_active"), res.getActiveElement());
    if (json.has("name")) {
      JsonArray array = json.getAsJsonArray("name");
      for (int i = 0; i < array.size(); i++) {
        res.getName().add(parseHumanName(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    if (json.has("birthDate"))
      res.setBirthDateElement(parseDate(json.get("birthDate").getAsString()));
    if (json.has("_birthDate"))
      parseElementProperties(json.getAsJsonObject("_birthDate"), res.getBirthDateElement());
    Type deceased = parseType("deceased", json);
    if (deceased != null)
      res.setDeceased(deceased);
    if (json.has("address")) {
      JsonArray array = json.getAsJsonArray("address");
      for (int i = 0; i < array.size(); i++) {
        res.getAddress().add(parseAddress(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("maritalStatus"))
      res.setMaritalStatus(parseCodeableConcept(json.getAsJsonObject("maritalStatus")));
    Type multipleBirth = parseType("multipleBirth", json);
    if (multipleBirth != null)
      res.setMultipleBirth(multipleBirth);
    if (json.has("photo")) {
      JsonArray array = json.getAsJsonArray("photo");
      for (int i = 0; i < array.size(); i++) {
        res.getPhoto().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parsePatientContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("animal"))
      res.setAnimal(parsePatientAnimalComponent(json.getAsJsonObject("animal"), res));
    if (json.has("communication")) {
      JsonArray array = json.getAsJsonArray("communication");
      for (int i = 0; i < array.size(); i++) {
        res.getCommunication().add(parsePatientPatientCommunicationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("careProvider")) {
      JsonArray array = json.getAsJsonArray("careProvider");
      for (int i = 0; i < array.size(); i++) {
        res.getCareProvider().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("managingOrganization"))
      res.setManagingOrganization(parseReference(json.getAsJsonObject("managingOrganization")));
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parsePatientPatientLinkComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Patient.ContactComponent parsePatientContactComponent(JsonObject json, Patient owner)
      throws IOException, FHIRFormatError {
    Patient.ContactComponent res = new Patient.ContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("relationship")) {
      JsonArray array = json.getAsJsonArray("relationship");
      for (int i = 0; i < array.size(); i++) {
        res.getRelationship().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("name"))
      res.setName(parseHumanName(json.getAsJsonObject("name")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("address"))
      res.setAddress(parseAddress(json.getAsJsonObject("address")));
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected Patient.AnimalComponent parsePatientAnimalComponent(JsonObject json, Patient owner)
      throws IOException, FHIRFormatError {
    Patient.AnimalComponent res = new Patient.AnimalComponent();
    parseBackboneProperties(json, res);
    if (json.has("species"))
      res.setSpecies(parseCodeableConcept(json.getAsJsonObject("species")));
    if (json.has("breed"))
      res.setBreed(parseCodeableConcept(json.getAsJsonObject("breed")));
    if (json.has("genderStatus"))
      res.setGenderStatus(parseCodeableConcept(json.getAsJsonObject("genderStatus")));
    return res;
  }

  protected Patient.PatientCommunicationComponent parsePatientPatientCommunicationComponent(JsonObject json,
      Patient owner) throws IOException, FHIRFormatError {
    Patient.PatientCommunicationComponent res = new Patient.PatientCommunicationComponent();
    parseBackboneProperties(json, res);
    if (json.has("language"))
      res.setLanguage(parseCodeableConcept(json.getAsJsonObject("language")));
    if (json.has("preferred"))
      res.setPreferredElement(parseBoolean(json.get("preferred").getAsBoolean()));
    if (json.has("_preferred"))
      parseElementProperties(json.getAsJsonObject("_preferred"), res.getPreferredElement());
    return res;
  }

  protected Patient.PatientLinkComponent parsePatientPatientLinkComponent(JsonObject json, Patient owner)
      throws IOException, FHIRFormatError {
    Patient.PatientLinkComponent res = new Patient.PatientLinkComponent();
    parseBackboneProperties(json, res);
    if (json.has("other"))
      res.setOther(parseReference(json.getAsJsonObject("other")));
    if (json.has("type"))
      res.setTypeElement(
          parseEnumeration(json.get("type").getAsString(), Patient.LinkType.NULL, new Patient.LinkTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    return res;
  }

  protected PaymentNotice parsePaymentNotice(JsonObject json) throws IOException, FHIRFormatError {
    PaymentNotice res = new PaymentNotice();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("response"))
      res.setResponse(parseReference(json.getAsJsonObject("response")));
    if (json.has("paymentStatus"))
      res.setPaymentStatus(parseCoding(json.getAsJsonObject("paymentStatus")));
    return res;
  }

  protected PaymentReconciliation parsePaymentReconciliation(JsonObject json) throws IOException, FHIRFormatError {
    PaymentReconciliation res = new PaymentReconciliation();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.RemittanceOutcome.NULL,
          new Enumerations.RemittanceOutcomeEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(json.getAsJsonObject("_outcome"), res.getOutcomeElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    if (json.has("detail")) {
      JsonArray array = json.getAsJsonArray("detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parsePaymentReconciliationDetailsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("form"))
      res.setForm(parseCoding(json.getAsJsonObject("form")));
    if (json.has("total"))
      res.setTotal(parseMoney(json.getAsJsonObject("total")));
    if (json.has("note")) {
      JsonArray array = json.getAsJsonArray("note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parsePaymentReconciliationNotesComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected PaymentReconciliation.DetailsComponent parsePaymentReconciliationDetailsComponent(JsonObject json,
      PaymentReconciliation owner) throws IOException, FHIRFormatError {
    PaymentReconciliation.DetailsComponent res = new PaymentReconciliation.DetailsComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("responce"))
      res.setResponce(parseReference(json.getAsJsonObject("responce")));
    if (json.has("submitter"))
      res.setSubmitter(parseReference(json.getAsJsonObject("submitter")));
    if (json.has("payee"))
      res.setPayee(parseReference(json.getAsJsonObject("payee")));
    if (json.has("date"))
      res.setDateElement(parseDate(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("amount"))
      res.setAmount(parseMoney(json.getAsJsonObject("amount")));
    return res;
  }

  protected PaymentReconciliation.NotesComponent parsePaymentReconciliationNotesComponent(JsonObject json,
      PaymentReconciliation owner) throws IOException, FHIRFormatError {
    PaymentReconciliation.NotesComponent res = new PaymentReconciliation.NotesComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected Person parsePerson(JsonObject json) throws IOException, FHIRFormatError {
    Person res = new Person();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("name")) {
      JsonArray array = json.getAsJsonArray("name");
      for (int i = 0; i < array.size(); i++) {
        res.getName().add(parseHumanName(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    if (json.has("birthDate"))
      res.setBirthDateElement(parseDate(json.get("birthDate").getAsString()));
    if (json.has("_birthDate"))
      parseElementProperties(json.getAsJsonObject("_birthDate"), res.getBirthDateElement());
    if (json.has("address")) {
      JsonArray array = json.getAsJsonArray("address");
      for (int i = 0; i < array.size(); i++) {
        res.getAddress().add(parseAddress(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("photo"))
      res.setPhoto(parseAttachment(json.getAsJsonObject("photo")));
    if (json.has("managingOrganization"))
      res.setManagingOrganization(parseReference(json.getAsJsonObject("managingOrganization")));
    if (json.has("active"))
      res.setActiveElement(parseBoolean(json.get("active").getAsBoolean()));
    if (json.has("_active"))
      parseElementProperties(json.getAsJsonObject("_active"), res.getActiveElement());
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parsePersonPersonLinkComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Person.PersonLinkComponent parsePersonPersonLinkComponent(JsonObject json, Person owner)
      throws IOException, FHIRFormatError {
    Person.PersonLinkComponent res = new Person.PersonLinkComponent();
    parseBackboneProperties(json, res);
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("assurance"))
      res.setAssuranceElement(parseEnumeration(json.get("assurance").getAsString(), Person.IdentityAssuranceLevel.NULL,
          new Person.IdentityAssuranceLevelEnumFactory()));
    if (json.has("_assurance"))
      parseElementProperties(json.getAsJsonObject("_assurance"), res.getAssuranceElement());
    return res;
  }

  protected Practitioner parsePractitioner(JsonObject json) throws IOException, FHIRFormatError {
    Practitioner res = new Practitioner();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("active"))
      res.setActiveElement(parseBoolean(json.get("active").getAsBoolean()));
    if (json.has("_active"))
      parseElementProperties(json.getAsJsonObject("_active"), res.getActiveElement());
    if (json.has("name"))
      res.setName(parseHumanName(json.getAsJsonObject("name")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("address")) {
      JsonArray array = json.getAsJsonArray("address");
      for (int i = 0; i < array.size(); i++) {
        res.getAddress().add(parseAddress(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    if (json.has("birthDate"))
      res.setBirthDateElement(parseDate(json.get("birthDate").getAsString()));
    if (json.has("_birthDate"))
      parseElementProperties(json.getAsJsonObject("_birthDate"), res.getBirthDateElement());
    if (json.has("photo")) {
      JsonArray array = json.getAsJsonArray("photo");
      for (int i = 0; i < array.size(); i++) {
        res.getPhoto().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("practitionerRole")) {
      JsonArray array = json.getAsJsonArray("practitionerRole");
      for (int i = 0; i < array.size(); i++) {
        res.getPractitionerRole()
            .add(parsePractitionerPractitionerPractitionerRoleComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("qualification")) {
      JsonArray array = json.getAsJsonArray("qualification");
      for (int i = 0; i < array.size(); i++) {
        res.getQualification()
            .add(parsePractitionerPractitionerQualificationComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("communication")) {
      JsonArray array = json.getAsJsonArray("communication");
      for (int i = 0; i < array.size(); i++) {
        res.getCommunication().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Practitioner.PractitionerPractitionerRoleComponent parsePractitionerPractitionerPractitionerRoleComponent(
      JsonObject json, Practitioner owner) throws IOException, FHIRFormatError {
    Practitioner.PractitionerPractitionerRoleComponent res = new Practitioner.PractitionerPractitionerRoleComponent();
    parseBackboneProperties(json, res);
    if (json.has("managingOrganization"))
      res.setManagingOrganization(parseReference(json.getAsJsonObject("managingOrganization")));
    if (json.has("role"))
      res.setRole(parseCodeableConcept(json.getAsJsonObject("role")));
    if (json.has("specialty")) {
      JsonArray array = json.getAsJsonArray("specialty");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialty().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("location")) {
      JsonArray array = json.getAsJsonArray("location");
      for (int i = 0; i < array.size(); i++) {
        res.getLocation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("healthcareService")) {
      JsonArray array = json.getAsJsonArray("healthcareService");
      for (int i = 0; i < array.size(); i++) {
        res.getHealthcareService().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Practitioner.PractitionerQualificationComponent parsePractitionerPractitionerQualificationComponent(
      JsonObject json, Practitioner owner) throws IOException, FHIRFormatError {
    Practitioner.PractitionerQualificationComponent res = new Practitioner.PractitionerQualificationComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("issuer"))
      res.setIssuer(parseReference(json.getAsJsonObject("issuer")));
    return res;
  }

  protected Procedure parseProcedure(JsonObject json) throws IOException, FHIRFormatError {
    Procedure res = new Procedure();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Procedure.ProcedureStatus.NULL,
          new Procedure.ProcedureStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(json.getAsJsonObject("category")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("notPerformed"))
      res.setNotPerformedElement(parseBoolean(json.get("notPerformed").getAsBoolean()));
    if (json.has("_notPerformed"))
      parseElementProperties(json.getAsJsonObject("_notPerformed"), res.getNotPerformedElement());
    if (json.has("reasonNotPerformed")) {
      JsonArray array = json.getAsJsonArray("reasonNotPerformed");
      for (int i = 0; i < array.size(); i++) {
        res.getReasonNotPerformed().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("bodySite")) {
      JsonArray array = json.getAsJsonArray("bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    if (json.has("performer")) {
      JsonArray array = json.getAsJsonArray("performer");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformer().add(parseProcedureProcedurePerformerComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    Type performed = parseType("performed", json);
    if (performed != null)
      res.setPerformed(performed);
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("outcome"))
      res.setOutcome(parseCodeableConcept(json.getAsJsonObject("outcome")));
    if (json.has("report")) {
      JsonArray array = json.getAsJsonArray("report");
      for (int i = 0; i < array.size(); i++) {
        res.getReport().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("complication")) {
      JsonArray array = json.getAsJsonArray("complication");
      for (int i = 0; i < array.size(); i++) {
        res.getComplication().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("followUp")) {
      JsonArray array = json.getAsJsonArray("followUp");
      for (int i = 0; i < array.size(); i++) {
        res.getFollowUp().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("notes")) {
      JsonArray array = json.getAsJsonArray("notes");
      for (int i = 0; i < array.size(); i++) {
        res.getNotes().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("focalDevice")) {
      JsonArray array = json.getAsJsonArray("focalDevice");
      for (int i = 0; i < array.size(); i++) {
        res.getFocalDevice().add(parseProcedureProcedureFocalDeviceComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("used")) {
      JsonArray array = json.getAsJsonArray("used");
      for (int i = 0; i < array.size(); i++) {
        res.getUsed().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Procedure.ProcedurePerformerComponent parseProcedureProcedurePerformerComponent(JsonObject json,
      Procedure owner) throws IOException, FHIRFormatError {
    Procedure.ProcedurePerformerComponent res = new Procedure.ProcedurePerformerComponent();
    parseBackboneProperties(json, res);
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    if (json.has("role"))
      res.setRole(parseCodeableConcept(json.getAsJsonObject("role")));
    return res;
  }

  protected Procedure.ProcedureFocalDeviceComponent parseProcedureProcedureFocalDeviceComponent(JsonObject json,
      Procedure owner) throws IOException, FHIRFormatError {
    Procedure.ProcedureFocalDeviceComponent res = new Procedure.ProcedureFocalDeviceComponent();
    parseBackboneProperties(json, res);
    if (json.has("action"))
      res.setAction(parseCodeableConcept(json.getAsJsonObject("action")));
    if (json.has("manipulated"))
      res.setManipulated(parseReference(json.getAsJsonObject("manipulated")));
    return res;
  }

  protected ProcedureRequest parseProcedureRequest(JsonObject json) throws IOException, FHIRFormatError {
    ProcedureRequest res = new ProcedureRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("bodySite")) {
      JsonArray array = json.getAsJsonArray("bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    Type scheduled = parseType("scheduled", json);
    if (scheduled != null)
      res.setScheduled(scheduled);
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("performer"))
      res.setPerformer(parseReference(json.getAsJsonObject("performer")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          ProcedureRequest.ProcedureRequestStatus.NULL, new ProcedureRequest.ProcedureRequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("notes")) {
      JsonArray array = json.getAsJsonArray("notes");
      for (int i = 0; i < array.size(); i++) {
        res.getNotes().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type asNeeded = parseType("asNeeded", json);
    if (asNeeded != null)
      res.setAsNeeded(asNeeded);
    if (json.has("orderedOn"))
      res.setOrderedOnElement(parseDateTime(json.get("orderedOn").getAsString()));
    if (json.has("_orderedOn"))
      parseElementProperties(json.getAsJsonObject("_orderedOn"), res.getOrderedOnElement());
    if (json.has("orderer"))
      res.setOrderer(parseReference(json.getAsJsonObject("orderer")));
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(),
          ProcedureRequest.ProcedureRequestPriority.NULL, new ProcedureRequest.ProcedureRequestPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(json.getAsJsonObject("_priority"), res.getPriorityElement());
    return res;
  }

  protected ProcessRequest parseProcessRequest(JsonObject json) throws IOException, FHIRFormatError {
    ProcessRequest res = new ProcessRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("action"))
      res.setActionElement(parseEnumeration(json.get("action").getAsString(), ProcessRequest.ActionList.NULL,
          new ProcessRequest.ActionListEnumFactory()));
    if (json.has("_action"))
      parseElementProperties(json.getAsJsonObject("_action"), res.getActionElement());
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("target"))
      res.setTarget(parseReference(json.getAsJsonObject("target")));
    if (json.has("provider"))
      res.setProvider(parseReference(json.getAsJsonObject("provider")));
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("response"))
      res.setResponse(parseReference(json.getAsJsonObject("response")));
    if (json.has("nullify"))
      res.setNullifyElement(parseBoolean(json.get("nullify").getAsBoolean()));
    if (json.has("_nullify"))
      parseElementProperties(json.getAsJsonObject("_nullify"), res.getNullifyElement());
    if (json.has("reference"))
      res.setReferenceElement(parseString(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(json.getAsJsonObject("_reference"), res.getReferenceElement());
    if (json.has("item")) {
      JsonArray array = json.getAsJsonArray("item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseProcessRequestItemsComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("include")) {
      JsonArray array = json.getAsJsonArray("include");
      for (int i = 0; i < array.size(); i++) {
        res.getInclude().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_include")) {
      JsonArray array = json.getAsJsonArray("_include");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInclude().size())
          res.getInclude().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInclude().get(i));
      }
    }
    ;
    if (json.has("exclude")) {
      JsonArray array = json.getAsJsonArray("exclude");
      for (int i = 0; i < array.size(); i++) {
        res.getExclude().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_exclude")) {
      JsonArray array = json.getAsJsonArray("_exclude");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getExclude().size())
          res.getExclude().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getExclude().get(i));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected ProcessRequest.ItemsComponent parseProcessRequestItemsComponent(JsonObject json, ProcessRequest owner)
      throws IOException, FHIRFormatError {
    ProcessRequest.ItemsComponent res = new ProcessRequest.ItemsComponent();
    parseBackboneProperties(json, res);
    if (json.has("sequenceLinkId"))
      res.setSequenceLinkIdElement(parseInteger(json.get("sequenceLinkId").getAsLong()));
    if (json.has("_sequenceLinkId"))
      parseElementProperties(json.getAsJsonObject("_sequenceLinkId"), res.getSequenceLinkIdElement());
    return res;
  }

  protected ProcessResponse parseProcessResponse(JsonObject json) throws IOException, FHIRFormatError {
    ProcessResponse res = new ProcessResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("request"))
      res.setRequest(parseReference(json.getAsJsonObject("request")));
    if (json.has("outcome"))
      res.setOutcome(parseCoding(json.getAsJsonObject("outcome")));
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(json.getAsJsonObject("_disposition"), res.getDispositionElement());
    if (json.has("ruleset"))
      res.setRuleset(parseCoding(json.getAsJsonObject("ruleset")));
    if (json.has("originalRuleset"))
      res.setOriginalRuleset(parseCoding(json.getAsJsonObject("originalRuleset")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(json.getAsJsonObject("_created"), res.getCreatedElement());
    if (json.has("organization"))
      res.setOrganization(parseReference(json.getAsJsonObject("organization")));
    if (json.has("requestProvider"))
      res.setRequestProvider(parseReference(json.getAsJsonObject("requestProvider")));
    if (json.has("requestOrganization"))
      res.setRequestOrganization(parseReference(json.getAsJsonObject("requestOrganization")));
    if (json.has("form"))
      res.setForm(parseCoding(json.getAsJsonObject("form")));
    if (json.has("notes")) {
      JsonArray array = json.getAsJsonArray("notes");
      for (int i = 0; i < array.size(); i++) {
        res.getNotes().add(parseProcessResponseProcessResponseNotesComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("error")) {
      JsonArray array = json.getAsJsonArray("error");
      for (int i = 0; i < array.size(); i++) {
        res.getError().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ProcessResponse.ProcessResponseNotesComponent parseProcessResponseProcessResponseNotesComponent(
      JsonObject json, ProcessResponse owner) throws IOException, FHIRFormatError {
    ProcessResponse.ProcessResponseNotesComponent res = new ProcessResponse.ProcessResponseNotesComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    return res;
  }

  protected Provenance parseProvenance(JsonObject json) throws IOException, FHIRFormatError {
    Provenance res = new Provenance();
    parseDomainResourceProperties(json, res);
    if (json.has("target")) {
      JsonArray array = json.getAsJsonArray("target");
      for (int i = 0; i < array.size(); i++) {
        res.getTarget().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    if (json.has("recorded"))
      res.setRecordedElement(parseInstant(json.get("recorded").getAsString()));
    if (json.has("_recorded"))
      parseElementProperties(json.getAsJsonObject("_recorded"), res.getRecordedElement());
    if (json.has("reason")) {
      JsonArray array = json.getAsJsonArray("reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("activity"))
      res.setActivity(parseCodeableConcept(json.getAsJsonObject("activity")));
    if (json.has("location"))
      res.setLocation(parseReference(json.getAsJsonObject("location")));
    if (json.has("policy")) {
      JsonArray array = json.getAsJsonArray("policy");
      for (int i = 0; i < array.size(); i++) {
        res.getPolicy().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_policy")) {
      JsonArray array = json.getAsJsonArray("_policy");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPolicy().size())
          res.getPolicy().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPolicy().get(i));
      }
    }
    ;
    if (json.has("agent")) {
      JsonArray array = json.getAsJsonArray("agent");
      for (int i = 0; i < array.size(); i++) {
        res.getAgent().add(parseProvenanceProvenanceAgentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("entity")) {
      JsonArray array = json.getAsJsonArray("entity");
      for (int i = 0; i < array.size(); i++) {
        res.getEntity().add(parseProvenanceProvenanceEntityComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("signature")) {
      JsonArray array = json.getAsJsonArray("signature");
      for (int i = 0; i < array.size(); i++) {
        res.getSignature().add(parseSignature(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Provenance.ProvenanceAgentComponent parseProvenanceProvenanceAgentComponent(JsonObject json,
      Provenance owner) throws IOException, FHIRFormatError {
    Provenance.ProvenanceAgentComponent res = new Provenance.ProvenanceAgentComponent();
    parseBackboneProperties(json, res);
    if (json.has("role"))
      res.setRole(parseCoding(json.getAsJsonObject("role")));
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    if (json.has("userId"))
      res.setUserId(parseIdentifier(json.getAsJsonObject("userId")));
    if (json.has("relatedAgent")) {
      JsonArray array = json.getAsJsonArray("relatedAgent");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedAgent()
            .add(parseProvenanceProvenanceAgentRelatedAgentComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Provenance.ProvenanceAgentRelatedAgentComponent parseProvenanceProvenanceAgentRelatedAgentComponent(
      JsonObject json, Provenance owner) throws IOException, FHIRFormatError {
    Provenance.ProvenanceAgentRelatedAgentComponent res = new Provenance.ProvenanceAgentRelatedAgentComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("target"))
      res.setTargetElement(parseUri(json.get("target").getAsString()));
    if (json.has("_target"))
      parseElementProperties(json.getAsJsonObject("_target"), res.getTargetElement());
    return res;
  }

  protected Provenance.ProvenanceEntityComponent parseProvenanceProvenanceEntityComponent(JsonObject json,
      Provenance owner) throws IOException, FHIRFormatError {
    Provenance.ProvenanceEntityComponent res = new Provenance.ProvenanceEntityComponent();
    parseBackboneProperties(json, res);
    if (json.has("role"))
      res.setRoleElement(parseEnumeration(json.get("role").getAsString(), Provenance.ProvenanceEntityRole.NULL,
          new Provenance.ProvenanceEntityRoleEnumFactory()));
    if (json.has("_role"))
      parseElementProperties(json.getAsJsonObject("_role"), res.getRoleElement());
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("reference"))
      res.setReferenceElement(parseUri(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(json.getAsJsonObject("_reference"), res.getReferenceElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("agent"))
      res.setAgent(parseProvenanceProvenanceAgentComponent(json.getAsJsonObject("agent"), owner));
    return res;
  }

  protected Questionnaire parseQuestionnaire(JsonObject json) throws IOException, FHIRFormatError {
    Questionnaire res = new Questionnaire();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Questionnaire.QuestionnaireStatus.NULL,
          new Questionnaire.QuestionnaireStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subjectType")) {
      JsonArray array = json.getAsJsonArray("subjectType");
      for (int i = 0; i < array.size(); i++) {
        res.getSubjectType().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_subjectType")) {
      JsonArray array = json.getAsJsonArray("_subjectType");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSubjectType().size())
          res.getSubjectType().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSubjectType().get(i));
      }
    }
    ;
    if (json.has("group"))
      res.setGroup(parseQuestionnaireGroupComponent(json.getAsJsonObject("group"), res));
    return res;
  }

  protected Questionnaire.GroupComponent parseQuestionnaireGroupComponent(JsonObject json, Questionnaire owner)
      throws IOException, FHIRFormatError {
    Questionnaire.GroupComponent res = new Questionnaire.GroupComponent();
    parseBackboneProperties(json, res);
    if (json.has("linkId"))
      res.setLinkIdElement(parseString(json.get("linkId").getAsString()));
    if (json.has("_linkId"))
      parseElementProperties(json.getAsJsonObject("_linkId"), res.getLinkIdElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("concept")) {
      JsonArray array = json.getAsJsonArray("concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("required"))
      res.setRequiredElement(parseBoolean(json.get("required").getAsBoolean()));
    if (json.has("_required"))
      parseElementProperties(json.getAsJsonObject("_required"), res.getRequiredElement());
    if (json.has("repeats"))
      res.setRepeatsElement(parseBoolean(json.get("repeats").getAsBoolean()));
    if (json.has("_repeats"))
      parseElementProperties(json.getAsJsonObject("_repeats"), res.getRepeatsElement());
    if (json.has("group")) {
      JsonArray array = json.getAsJsonArray("group");
      for (int i = 0; i < array.size(); i++) {
        res.getGroup().add(parseQuestionnaireGroupComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("question")) {
      JsonArray array = json.getAsJsonArray("question");
      for (int i = 0; i < array.size(); i++) {
        res.getQuestion().add(parseQuestionnaireQuestionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected Questionnaire.QuestionComponent parseQuestionnaireQuestionComponent(JsonObject json, Questionnaire owner)
      throws IOException, FHIRFormatError {
    Questionnaire.QuestionComponent res = new Questionnaire.QuestionComponent();
    parseBackboneProperties(json, res);
    if (json.has("linkId"))
      res.setLinkIdElement(parseString(json.get("linkId").getAsString()));
    if (json.has("_linkId"))
      parseElementProperties(json.getAsJsonObject("_linkId"), res.getLinkIdElement());
    if (json.has("concept")) {
      JsonArray array = json.getAsJsonArray("concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Questionnaire.AnswerFormat.NULL,
          new Questionnaire.AnswerFormatEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("required"))
      res.setRequiredElement(parseBoolean(json.get("required").getAsBoolean()));
    if (json.has("_required"))
      parseElementProperties(json.getAsJsonObject("_required"), res.getRequiredElement());
    if (json.has("repeats"))
      res.setRepeatsElement(parseBoolean(json.get("repeats").getAsBoolean()));
    if (json.has("_repeats"))
      parseElementProperties(json.getAsJsonObject("_repeats"), res.getRepeatsElement());
    if (json.has("options"))
      res.setOptions(parseReference(json.getAsJsonObject("options")));
    if (json.has("option")) {
      JsonArray array = json.getAsJsonArray("option");
      for (int i = 0; i < array.size(); i++) {
        res.getOption().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("group")) {
      JsonArray array = json.getAsJsonArray("group");
      for (int i = 0; i < array.size(); i++) {
        res.getGroup().add(parseQuestionnaireGroupComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected QuestionnaireResponse parseQuestionnaireResponse(JsonObject json) throws IOException, FHIRFormatError {
    QuestionnaireResponse res = new QuestionnaireResponse();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("questionnaire"))
      res.setQuestionnaire(parseReference(json.getAsJsonObject("questionnaire")));
    if (json.has("status"))
      res.setStatusElement(
          parseEnumeration(json.get("status").getAsString(), QuestionnaireResponse.QuestionnaireResponseStatus.NULL,
              new QuestionnaireResponse.QuestionnaireResponseStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("author"))
      res.setAuthor(parseReference(json.getAsJsonObject("author")));
    if (json.has("authored"))
      res.setAuthoredElement(parseDateTime(json.get("authored").getAsString()));
    if (json.has("_authored"))
      parseElementProperties(json.getAsJsonObject("_authored"), res.getAuthoredElement());
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("group"))
      res.setGroup(parseQuestionnaireResponseGroupComponent(json.getAsJsonObject("group"), res));
    return res;
  }

  protected QuestionnaireResponse.GroupComponent parseQuestionnaireResponseGroupComponent(JsonObject json,
      QuestionnaireResponse owner) throws IOException, FHIRFormatError {
    QuestionnaireResponse.GroupComponent res = new QuestionnaireResponse.GroupComponent();
    parseBackboneProperties(json, res);
    if (json.has("linkId"))
      res.setLinkIdElement(parseString(json.get("linkId").getAsString()));
    if (json.has("_linkId"))
      parseElementProperties(json.getAsJsonObject("_linkId"), res.getLinkIdElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(json.getAsJsonObject("_title"), res.getTitleElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("group")) {
      JsonArray array = json.getAsJsonArray("group");
      for (int i = 0; i < array.size(); i++) {
        res.getGroup().add(parseQuestionnaireResponseGroupComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("question")) {
      JsonArray array = json.getAsJsonArray("question");
      for (int i = 0; i < array.size(); i++) {
        res.getQuestion().add(parseQuestionnaireResponseQuestionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected QuestionnaireResponse.QuestionComponent parseQuestionnaireResponseQuestionComponent(JsonObject json,
      QuestionnaireResponse owner) throws IOException, FHIRFormatError {
    QuestionnaireResponse.QuestionComponent res = new QuestionnaireResponse.QuestionComponent();
    parseBackboneProperties(json, res);
    if (json.has("linkId"))
      res.setLinkIdElement(parseString(json.get("linkId").getAsString()));
    if (json.has("_linkId"))
      parseElementProperties(json.getAsJsonObject("_linkId"), res.getLinkIdElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(json.getAsJsonObject("_text"), res.getTextElement());
    if (json.has("answer")) {
      JsonArray array = json.getAsJsonArray("answer");
      for (int i = 0; i < array.size(); i++) {
        res.getAnswer().add(parseQuestionnaireResponseQuestionAnswerComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected QuestionnaireResponse.QuestionAnswerComponent parseQuestionnaireResponseQuestionAnswerComponent(
      JsonObject json, QuestionnaireResponse owner) throws IOException, FHIRFormatError {
    QuestionnaireResponse.QuestionAnswerComponent res = new QuestionnaireResponse.QuestionAnswerComponent();
    parseBackboneProperties(json, res);
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("group")) {
      JsonArray array = json.getAsJsonArray("group");
      for (int i = 0; i < array.size(); i++) {
        res.getGroup().add(parseQuestionnaireResponseGroupComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ReferralRequest parseReferralRequest(JsonObject json) throws IOException, FHIRFormatError {
    ReferralRequest res = new ReferralRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), ReferralRequest.ReferralStatus.NULL,
          new ReferralRequest.ReferralStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("specialty"))
      res.setSpecialty(parseCodeableConcept(json.getAsJsonObject("specialty")));
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(json.getAsJsonObject("priority")));
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("requester"))
      res.setRequester(parseReference(json.getAsJsonObject("requester")));
    if (json.has("recipient")) {
      JsonArray array = json.getAsJsonArray("recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("dateSent"))
      res.setDateSentElement(parseDateTime(json.get("dateSent").getAsString()));
    if (json.has("_dateSent"))
      parseElementProperties(json.getAsJsonObject("_dateSent"), res.getDateSentElement());
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(json.getAsJsonObject("reason")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("serviceRequested")) {
      JsonArray array = json.getAsJsonArray("serviceRequested");
      for (int i = 0; i < array.size(); i++) {
        res.getServiceRequested().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("supportingInformation")) {
      JsonArray array = json.getAsJsonArray("supportingInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("fulfillmentTime"))
      res.setFulfillmentTime(parsePeriod(json.getAsJsonObject("fulfillmentTime")));
    return res;
  }

  protected RelatedPerson parseRelatedPerson(JsonObject json) throws IOException, FHIRFormatError {
    RelatedPerson res = new RelatedPerson();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("relationship"))
      res.setRelationship(parseCodeableConcept(json.getAsJsonObject("relationship")));
    if (json.has("name"))
      res.setName(parseHumanName(json.getAsJsonObject("name")));
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("gender"))
      res.setGenderElement(parseEnumeration(json.get("gender").getAsString(), Enumerations.AdministrativeGender.NULL,
          new Enumerations.AdministrativeGenderEnumFactory()));
    if (json.has("_gender"))
      parseElementProperties(json.getAsJsonObject("_gender"), res.getGenderElement());
    if (json.has("birthDate"))
      res.setBirthDateElement(parseDate(json.get("birthDate").getAsString()));
    if (json.has("_birthDate"))
      parseElementProperties(json.getAsJsonObject("_birthDate"), res.getBirthDateElement());
    if (json.has("address")) {
      JsonArray array = json.getAsJsonArray("address");
      for (int i = 0; i < array.size(); i++) {
        res.getAddress().add(parseAddress(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("photo")) {
      JsonArray array = json.getAsJsonArray("photo");
      for (int i = 0; i < array.size(); i++) {
        res.getPhoto().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("period"))
      res.setPeriod(parsePeriod(json.getAsJsonObject("period")));
    return res;
  }

  protected RiskAssessment parseRiskAssessment(JsonObject json) throws IOException, FHIRFormatError {
    RiskAssessment res = new RiskAssessment();
    parseDomainResourceProperties(json, res);
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("condition"))
      res.setCondition(parseReference(json.getAsJsonObject("condition")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    if (json.has("performer"))
      res.setPerformer(parseReference(json.getAsJsonObject("performer")));
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    if (json.has("basis")) {
      JsonArray array = json.getAsJsonArray("basis");
      for (int i = 0; i < array.size(); i++) {
        res.getBasis().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("prediction")) {
      JsonArray array = json.getAsJsonArray("prediction");
      for (int i = 0; i < array.size(); i++) {
        res.getPrediction()
            .add(parseRiskAssessmentRiskAssessmentPredictionComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("mitigation"))
      res.setMitigationElement(parseString(json.get("mitigation").getAsString()));
    if (json.has("_mitigation"))
      parseElementProperties(json.getAsJsonObject("_mitigation"), res.getMitigationElement());
    return res;
  }

  protected RiskAssessment.RiskAssessmentPredictionComponent parseRiskAssessmentRiskAssessmentPredictionComponent(
      JsonObject json, RiskAssessment owner) throws IOException, FHIRFormatError {
    RiskAssessment.RiskAssessmentPredictionComponent res = new RiskAssessment.RiskAssessmentPredictionComponent();
    parseBackboneProperties(json, res);
    if (json.has("outcome"))
      res.setOutcome(parseCodeableConcept(json.getAsJsonObject("outcome")));
    Type probability = parseType("probability", json);
    if (probability != null)
      res.setProbability(probability);
    if (json.has("relativeRisk"))
      res.setRelativeRiskElement(parseDecimal(json.get("relativeRisk").getAsBigDecimal()));
    if (json.has("_relativeRisk"))
      parseElementProperties(json.getAsJsonObject("_relativeRisk"), res.getRelativeRiskElement());
    Type when = parseType("when", json);
    if (when != null)
      res.setWhen(when);
    if (json.has("rationale"))
      res.setRationaleElement(parseString(json.get("rationale").getAsString()));
    if (json.has("_rationale"))
      parseElementProperties(json.getAsJsonObject("_rationale"), res.getRationaleElement());
    return res;
  }

  protected Schedule parseSchedule(JsonObject json) throws IOException, FHIRFormatError {
    Schedule res = new Schedule();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type")) {
      JsonArray array = json.getAsJsonArray("type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("actor"))
      res.setActor(parseReference(json.getAsJsonObject("actor")));
    if (json.has("planningHorizon"))
      res.setPlanningHorizon(parsePeriod(json.getAsJsonObject("planningHorizon")));
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    return res;
  }

  protected SearchParameter parseSearchParameter(JsonObject json) throws IOException, FHIRFormatError {
    SearchParameter res = new SearchParameter();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseSearchParameterSearchParameterContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("base"))
      res.setBaseElement(parseCode(json.get("base").getAsString()));
    if (json.has("_base"))
      parseElementProperties(json.getAsJsonObject("_base"), res.getBaseElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.SearchParamType.NULL,
          new Enumerations.SearchParamTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("xpath"))
      res.setXpathElement(parseString(json.get("xpath").getAsString()));
    if (json.has("_xpath"))
      parseElementProperties(json.getAsJsonObject("_xpath"), res.getXpathElement());
    if (json.has("xpathUsage"))
      res.setXpathUsageElement(parseEnumeration(json.get("xpathUsage").getAsString(),
          SearchParameter.XPathUsageType.NULL, new SearchParameter.XPathUsageTypeEnumFactory()));
    if (json.has("_xpathUsage"))
      parseElementProperties(json.getAsJsonObject("_xpathUsage"), res.getXpathUsageElement());
    if (json.has("target")) {
      JsonArray array = json.getAsJsonArray("target");
      for (int i = 0; i < array.size(); i++) {
        res.getTarget().add(parseCode(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_target")) {
      JsonArray array = json.getAsJsonArray("_target");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getTarget().size())
          res.getTarget().add(parseCode(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getTarget().get(i));
      }
    }
    ;
    return res;
  }

  protected SearchParameter.SearchParameterContactComponent parseSearchParameterSearchParameterContactComponent(
      JsonObject json, SearchParameter owner) throws IOException, FHIRFormatError {
    SearchParameter.SearchParameterContactComponent res = new SearchParameter.SearchParameterContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Slot parseSlot(JsonObject json) throws IOException, FHIRFormatError {
    Slot res = new Slot();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("schedule"))
      res.setSchedule(parseReference(json.getAsJsonObject("schedule")));
    if (json.has("freeBusyType"))
      res.setFreeBusyTypeElement(parseEnumeration(json.get("freeBusyType").getAsString(), Slot.SlotStatus.NULL,
          new Slot.SlotStatusEnumFactory()));
    if (json.has("_freeBusyType"))
      parseElementProperties(json.getAsJsonObject("_freeBusyType"), res.getFreeBusyTypeElement());
    if (json.has("start"))
      res.setStartElement(parseInstant(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(json.getAsJsonObject("_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(json.getAsJsonObject("_end"), res.getEndElement());
    if (json.has("overbooked"))
      res.setOverbookedElement(parseBoolean(json.get("overbooked").getAsBoolean()));
    if (json.has("_overbooked"))
      parseElementProperties(json.getAsJsonObject("_overbooked"), res.getOverbookedElement());
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(json.getAsJsonObject("_comment"), res.getCommentElement());
    return res;
  }

  protected Specimen parseSpecimen(JsonObject json) throws IOException, FHIRFormatError {
    Specimen res = new Specimen();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Specimen.SpecimenStatus.NULL,
          new Specimen.SpecimenStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("parent")) {
      JsonArray array = json.getAsJsonArray("parent");
      for (int i = 0; i < array.size(); i++) {
        res.getParent().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("subject"))
      res.setSubject(parseReference(json.getAsJsonObject("subject")));
    if (json.has("accessionIdentifier"))
      res.setAccessionIdentifier(parseIdentifier(json.getAsJsonObject("accessionIdentifier")));
    if (json.has("receivedTime"))
      res.setReceivedTimeElement(parseDateTime(json.get("receivedTime").getAsString()));
    if (json.has("_receivedTime"))
      parseElementProperties(json.getAsJsonObject("_receivedTime"), res.getReceivedTimeElement());
    if (json.has("collection"))
      res.setCollection(parseSpecimenSpecimenCollectionComponent(json.getAsJsonObject("collection"), res));
    if (json.has("treatment")) {
      JsonArray array = json.getAsJsonArray("treatment");
      for (int i = 0; i < array.size(); i++) {
        res.getTreatment().add(parseSpecimenSpecimenTreatmentComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("container")) {
      JsonArray array = json.getAsJsonArray("container");
      for (int i = 0; i < array.size(); i++) {
        res.getContainer().add(parseSpecimenSpecimenContainerComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Specimen.SpecimenCollectionComponent parseSpecimenSpecimenCollectionComponent(JsonObject json,
      Specimen owner) throws IOException, FHIRFormatError {
    Specimen.SpecimenCollectionComponent res = new Specimen.SpecimenCollectionComponent();
    parseBackboneProperties(json, res);
    if (json.has("collector"))
      res.setCollector(parseReference(json.getAsJsonObject("collector")));
    if (json.has("comment")) {
      JsonArray array = json.getAsJsonArray("comment");
      for (int i = 0; i < array.size(); i++) {
        res.getComment().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_comment")) {
      JsonArray array = json.getAsJsonArray("_comment");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getComment().size())
          res.getComment().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getComment().get(i));
      }
    }
    ;
    Type collected = parseType("collected", json);
    if (collected != null)
      res.setCollected(collected);
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(json.getAsJsonObject("method")));
    if (json.has("bodySite"))
      res.setBodySite(parseCodeableConcept(json.getAsJsonObject("bodySite")));
    return res;
  }

  protected Specimen.SpecimenTreatmentComponent parseSpecimenSpecimenTreatmentComponent(JsonObject json, Specimen owner)
      throws IOException, FHIRFormatError {
    Specimen.SpecimenTreatmentComponent res = new Specimen.SpecimenTreatmentComponent();
    parseBackboneProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("procedure"))
      res.setProcedure(parseCodeableConcept(json.getAsJsonObject("procedure")));
    if (json.has("additive")) {
      JsonArray array = json.getAsJsonArray("additive");
      for (int i = 0; i < array.size(); i++) {
        res.getAdditive().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Specimen.SpecimenContainerComponent parseSpecimenSpecimenContainerComponent(JsonObject json, Specimen owner)
      throws IOException, FHIRFormatError {
    Specimen.SpecimenContainerComponent res = new Specimen.SpecimenContainerComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("capacity"))
      res.setCapacity(parseSimpleQuantity(json.getAsJsonObject("capacity")));
    if (json.has("specimenQuantity"))
      res.setSpecimenQuantity(parseSimpleQuantity(json.getAsJsonObject("specimenQuantity")));
    Type additive = parseType("additive", json);
    if (additive != null)
      res.setAdditive(additive);
    return res;
  }

  protected StructureDefinition parseStructureDefinition(JsonObject json) throws IOException, FHIRFormatError {
    StructureDefinition res = new StructureDefinition();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact()
            .add(parseStructureDefinitionStructureDefinitionContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("code")) {
      JsonArray array = json.getAsJsonArray("code");
      for (int i = 0; i < array.size(); i++) {
        res.getCode().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("fhirVersion"))
      res.setFhirVersionElement(parseId(json.get("fhirVersion").getAsString()));
    if (json.has("_fhirVersion"))
      parseElementProperties(json.getAsJsonObject("_fhirVersion"), res.getFhirVersionElement());
    if (json.has("mapping")) {
      JsonArray array = json.getAsJsonArray("mapping");
      for (int i = 0; i < array.size(); i++) {
        res.getMapping()
            .add(parseStructureDefinitionStructureDefinitionMappingComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("kind"))
      res.setKindElement(
          parseEnumeration(json.get("kind").getAsString(), StructureDefinition.StructureDefinitionKind.NULL,
              new StructureDefinition.StructureDefinitionKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(json.getAsJsonObject("_kind"), res.getKindElement());
    if (json.has("constrainedType"))
      res.setConstrainedTypeElement(parseCode(json.get("constrainedType").getAsString()));
    if (json.has("_constrainedType"))
      parseElementProperties(json.getAsJsonObject("_constrainedType"), res.getConstrainedTypeElement());
    if (json.has("abstract"))
      res.setAbstractElement(parseBoolean(json.get("abstract").getAsBoolean()));
    if (json.has("_abstract"))
      parseElementProperties(json.getAsJsonObject("_abstract"), res.getAbstractElement());
    if (json.has("contextType"))
      res.setContextTypeElement(parseEnumeration(json.get("contextType").getAsString(),
          StructureDefinition.ExtensionContext.NULL, new StructureDefinition.ExtensionContextEnumFactory()));
    if (json.has("_contextType"))
      parseElementProperties(json.getAsJsonObject("_contextType"), res.getContextTypeElement());
    if (json.has("context")) {
      JsonArray array = json.getAsJsonArray("context");
      for (int i = 0; i < array.size(); i++) {
        res.getContext().add(parseString(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_context")) {
      JsonArray array = json.getAsJsonArray("_context");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getContext().size())
          res.getContext().add(parseString(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getContext().get(i));
      }
    }
    ;
    if (json.has("base"))
      res.setBaseElement(parseUri(json.get("base").getAsString()));
    if (json.has("_base"))
      parseElementProperties(json.getAsJsonObject("_base"), res.getBaseElement());
    if (json.has("snapshot"))
      res.setSnapshot(
          parseStructureDefinitionStructureDefinitionSnapshotComponent(json.getAsJsonObject("snapshot"), res));
    if (json.has("differential"))
      res.setDifferential(
          parseStructureDefinitionStructureDefinitionDifferentialComponent(json.getAsJsonObject("differential"), res));
    return res;
  }

  protected StructureDefinition.StructureDefinitionContactComponent parseStructureDefinitionStructureDefinitionContactComponent(
      JsonObject json, StructureDefinition owner) throws IOException, FHIRFormatError {
    StructureDefinition.StructureDefinitionContactComponent res = new StructureDefinition.StructureDefinitionContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected StructureDefinition.StructureDefinitionMappingComponent parseStructureDefinitionStructureDefinitionMappingComponent(
      JsonObject json, StructureDefinition owner) throws IOException, FHIRFormatError {
    StructureDefinition.StructureDefinitionMappingComponent res = new StructureDefinition.StructureDefinitionMappingComponent();
    parseBackboneProperties(json, res);
    if (json.has("identity"))
      res.setIdentityElement(parseId(json.get("identity").getAsString()));
    if (json.has("_identity"))
      parseElementProperties(json.getAsJsonObject("_identity"), res.getIdentityElement());
    if (json.has("uri"))
      res.setUriElement(parseUri(json.get("uri").getAsString()));
    if (json.has("_uri"))
      parseElementProperties(json.getAsJsonObject("_uri"), res.getUriElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("comments"))
      res.setCommentsElement(parseString(json.get("comments").getAsString()));
    if (json.has("_comments"))
      parseElementProperties(json.getAsJsonObject("_comments"), res.getCommentsElement());
    return res;
  }

  protected StructureDefinition.StructureDefinitionSnapshotComponent parseStructureDefinitionStructureDefinitionSnapshotComponent(
      JsonObject json, StructureDefinition owner) throws IOException, FHIRFormatError {
    StructureDefinition.StructureDefinitionSnapshotComponent res = new StructureDefinition.StructureDefinitionSnapshotComponent();
    parseBackboneProperties(json, res);
    if (json.has("element")) {
      JsonArray array = json.getAsJsonArray("element");
      for (int i = 0; i < array.size(); i++) {
        res.getElement().add(parseElementDefinition(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected StructureDefinition.StructureDefinitionDifferentialComponent parseStructureDefinitionStructureDefinitionDifferentialComponent(
      JsonObject json, StructureDefinition owner) throws IOException, FHIRFormatError {
    StructureDefinition.StructureDefinitionDifferentialComponent res = new StructureDefinition.StructureDefinitionDifferentialComponent();
    parseBackboneProperties(json, res);
    if (json.has("element")) {
      JsonArray array = json.getAsJsonArray("element");
      for (int i = 0; i < array.size(); i++) {
        res.getElement().add(parseElementDefinition(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Subscription parseSubscription(JsonObject json) throws IOException, FHIRFormatError {
    Subscription res = new Subscription();
    parseDomainResourceProperties(json, res);
    if (json.has("criteria"))
      res.setCriteriaElement(parseString(json.get("criteria").getAsString()));
    if (json.has("_criteria"))
      parseElementProperties(json.getAsJsonObject("_criteria"), res.getCriteriaElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("reason"))
      res.setReasonElement(parseString(json.get("reason").getAsString()));
    if (json.has("_reason"))
      parseElementProperties(json.getAsJsonObject("_reason"), res.getReasonElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Subscription.SubscriptionStatus.NULL,
          new Subscription.SubscriptionStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("error"))
      res.setErrorElement(parseString(json.get("error").getAsString()));
    if (json.has("_error"))
      parseElementProperties(json.getAsJsonObject("_error"), res.getErrorElement());
    if (json.has("channel"))
      res.setChannel(parseSubscriptionSubscriptionChannelComponent(json.getAsJsonObject("channel"), res));
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(json.getAsJsonObject("_end"), res.getEndElement());
    if (json.has("tag")) {
      JsonArray array = json.getAsJsonArray("tag");
      for (int i = 0; i < array.size(); i++) {
        res.getTag().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected Subscription.SubscriptionChannelComponent parseSubscriptionSubscriptionChannelComponent(JsonObject json,
      Subscription owner) throws IOException, FHIRFormatError {
    Subscription.SubscriptionChannelComponent res = new Subscription.SubscriptionChannelComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Subscription.SubscriptionChannelType.NULL,
          new Subscription.SubscriptionChannelTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(json.getAsJsonObject("_type"), res.getTypeElement());
    if (json.has("endpoint"))
      res.setEndpointElement(parseUri(json.get("endpoint").getAsString()));
    if (json.has("_endpoint"))
      parseElementProperties(json.getAsJsonObject("_endpoint"), res.getEndpointElement());
    if (json.has("payload"))
      res.setPayloadElement(parseString(json.get("payload").getAsString()));
    if (json.has("_payload"))
      parseElementProperties(json.getAsJsonObject("_payload"), res.getPayloadElement());
    if (json.has("header"))
      res.setHeaderElement(parseString(json.get("header").getAsString()));
    if (json.has("_header"))
      parseElementProperties(json.getAsJsonObject("_header"), res.getHeaderElement());
    return res;
  }

  protected Substance parseSubstance(JsonObject json) throws IOException, FHIRFormatError {
    Substance res = new Substance();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("category")) {
      JsonArray array = json.getAsJsonArray("category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("instance")) {
      JsonArray array = json.getAsJsonArray("instance");
      for (int i = 0; i < array.size(); i++) {
        res.getInstance().add(parseSubstanceSubstanceInstanceComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("ingredient")) {
      JsonArray array = json.getAsJsonArray("ingredient");
      for (int i = 0; i < array.size(); i++) {
        res.getIngredient().add(parseSubstanceSubstanceIngredientComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected Substance.SubstanceInstanceComponent parseSubstanceSubstanceInstanceComponent(JsonObject json,
      Substance owner) throws IOException, FHIRFormatError {
    Substance.SubstanceInstanceComponent res = new Substance.SubstanceInstanceComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("expiry"))
      res.setExpiryElement(parseDateTime(json.get("expiry").getAsString()));
    if (json.has("_expiry"))
      parseElementProperties(json.getAsJsonObject("_expiry"), res.getExpiryElement());
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    return res;
  }

  protected Substance.SubstanceIngredientComponent parseSubstanceSubstanceIngredientComponent(JsonObject json,
      Substance owner) throws IOException, FHIRFormatError {
    Substance.SubstanceIngredientComponent res = new Substance.SubstanceIngredientComponent();
    parseBackboneProperties(json, res);
    if (json.has("quantity"))
      res.setQuantity(parseRatio(json.getAsJsonObject("quantity")));
    if (json.has("substance"))
      res.setSubstance(parseReference(json.getAsJsonObject("substance")));
    return res;
  }

  protected SupplyDelivery parseSupplyDelivery(JsonObject json) throws IOException, FHIRFormatError {
    SupplyDelivery res = new SupplyDelivery();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), SupplyDelivery.SupplyDeliveryStatus.NULL,
          new SupplyDelivery.SupplyDeliveryStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("type"))
      res.setType(parseCodeableConcept(json.getAsJsonObject("type")));
    if (json.has("quantity"))
      res.setQuantity(parseSimpleQuantity(json.getAsJsonObject("quantity")));
    if (json.has("suppliedItem"))
      res.setSuppliedItem(parseReference(json.getAsJsonObject("suppliedItem")));
    if (json.has("supplier"))
      res.setSupplier(parseReference(json.getAsJsonObject("supplier")));
    if (json.has("whenPrepared"))
      res.setWhenPrepared(parsePeriod(json.getAsJsonObject("whenPrepared")));
    if (json.has("time"))
      res.setTimeElement(parseDateTime(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(json.getAsJsonObject("_time"), res.getTimeElement());
    if (json.has("destination"))
      res.setDestination(parseReference(json.getAsJsonObject("destination")));
    if (json.has("receiver")) {
      JsonArray array = json.getAsJsonArray("receiver");
      for (int i = 0; i < array.size(); i++) {
        res.getReceiver().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected SupplyRequest parseSupplyRequest(JsonObject json) throws IOException, FHIRFormatError {
    SupplyRequest res = new SupplyRequest();
    parseDomainResourceProperties(json, res);
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("source"))
      res.setSource(parseReference(json.getAsJsonObject("source")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), SupplyRequest.SupplyRequestStatus.NULL,
          new SupplyRequest.SupplyRequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("kind"))
      res.setKind(parseCodeableConcept(json.getAsJsonObject("kind")));
    if (json.has("orderedItem"))
      res.setOrderedItem(parseReference(json.getAsJsonObject("orderedItem")));
    if (json.has("supplier")) {
      JsonArray array = json.getAsJsonArray("supplier");
      for (int i = 0; i < array.size(); i++) {
        res.getSupplier().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    if (json.has("when"))
      res.setWhen(parseSupplyRequestSupplyRequestWhenComponent(json.getAsJsonObject("when"), res));
    return res;
  }

  protected SupplyRequest.SupplyRequestWhenComponent parseSupplyRequestSupplyRequestWhenComponent(JsonObject json,
      SupplyRequest owner) throws IOException, FHIRFormatError {
    SupplyRequest.SupplyRequestWhenComponent res = new SupplyRequest.SupplyRequestWhenComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(json.getAsJsonObject("code")));
    if (json.has("schedule"))
      res.setSchedule(parseTiming(json.getAsJsonObject("schedule")));
    return res;
  }

  protected TestScript parseTestScript(JsonObject json) throws IOException, FHIRFormatError {
    TestScript res = new TestScript();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseTestScriptTestScriptContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("metadata"))
      res.setMetadata(parseTestScriptTestScriptMetadataComponent(json.getAsJsonObject("metadata"), res));
    if (json.has("multiserver"))
      res.setMultiserverElement(parseBoolean(json.get("multiserver").getAsBoolean()));
    if (json.has("_multiserver"))
      parseElementProperties(json.getAsJsonObject("_multiserver"), res.getMultiserverElement());
    if (json.has("fixture")) {
      JsonArray array = json.getAsJsonArray("fixture");
      for (int i = 0; i < array.size(); i++) {
        res.getFixture().add(parseTestScriptTestScriptFixtureComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("profile")) {
      JsonArray array = json.getAsJsonArray("profile");
      for (int i = 0; i < array.size(); i++) {
        res.getProfile().add(parseReference(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("variable")) {
      JsonArray array = json.getAsJsonArray("variable");
      for (int i = 0; i < array.size(); i++) {
        res.getVariable().add(parseTestScriptTestScriptVariableComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("setup"))
      res.setSetup(parseTestScriptTestScriptSetupComponent(json.getAsJsonObject("setup"), res));
    if (json.has("test")) {
      JsonArray array = json.getAsJsonArray("test");
      for (int i = 0; i < array.size(); i++) {
        res.getTest().add(parseTestScriptTestScriptTestComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("teardown"))
      res.setTeardown(parseTestScriptTestScriptTeardownComponent(json.getAsJsonObject("teardown"), res));
    return res;
  }

  protected TestScript.TestScriptContactComponent parseTestScriptTestScriptContactComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptContactComponent res = new TestScript.TestScriptContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected TestScript.TestScriptMetadataComponent parseTestScriptTestScriptMetadataComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptMetadataComponent res = new TestScript.TestScriptMetadataComponent();
    parseBackboneProperties(json, res);
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseTestScriptTestScriptMetadataLinkComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("capability")) {
      JsonArray array = json.getAsJsonArray("capability");
      for (int i = 0; i < array.size(); i++) {
        res.getCapability()
            .add(parseTestScriptTestScriptMetadataCapabilityComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected TestScript.TestScriptMetadataLinkComponent parseTestScriptTestScriptMetadataLinkComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptMetadataLinkComponent res = new TestScript.TestScriptMetadataLinkComponent();
    parseBackboneProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    return res;
  }

  protected TestScript.TestScriptMetadataCapabilityComponent parseTestScriptTestScriptMetadataCapabilityComponent(
      JsonObject json, TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptMetadataCapabilityComponent res = new TestScript.TestScriptMetadataCapabilityComponent();
    parseBackboneProperties(json, res);
    if (json.has("required"))
      res.setRequiredElement(parseBoolean(json.get("required").getAsBoolean()));
    if (json.has("_required"))
      parseElementProperties(json.getAsJsonObject("_required"), res.getRequiredElement());
    if (json.has("validated"))
      res.setValidatedElement(parseBoolean(json.get("validated").getAsBoolean()));
    if (json.has("_validated"))
      parseElementProperties(json.getAsJsonObject("_validated"), res.getValidatedElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("destination"))
      res.setDestinationElement(parseInteger(json.get("destination").getAsLong()));
    if (json.has("_destination"))
      parseElementProperties(json.getAsJsonObject("_destination"), res.getDestinationElement());
    if (json.has("link")) {
      JsonArray array = json.getAsJsonArray("link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_link")) {
      JsonArray array = json.getAsJsonArray("_link");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getLink().size())
          res.getLink().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getLink().get(i));
      }
    }
    ;
    if (json.has("conformance"))
      res.setConformance(parseReference(json.getAsJsonObject("conformance")));
    return res;
  }

  protected TestScript.TestScriptFixtureComponent parseTestScriptTestScriptFixtureComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptFixtureComponent res = new TestScript.TestScriptFixtureComponent();
    parseBackboneProperties(json, res);
    if (json.has("autocreate"))
      res.setAutocreateElement(parseBoolean(json.get("autocreate").getAsBoolean()));
    if (json.has("_autocreate"))
      parseElementProperties(json.getAsJsonObject("_autocreate"), res.getAutocreateElement());
    if (json.has("autodelete"))
      res.setAutodeleteElement(parseBoolean(json.get("autodelete").getAsBoolean()));
    if (json.has("_autodelete"))
      parseElementProperties(json.getAsJsonObject("_autodelete"), res.getAutodeleteElement());
    if (json.has("resource"))
      res.setResource(parseReference(json.getAsJsonObject("resource")));
    return res;
  }

  protected TestScript.TestScriptVariableComponent parseTestScriptTestScriptVariableComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptVariableComponent res = new TestScript.TestScriptVariableComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("headerField"))
      res.setHeaderFieldElement(parseString(json.get("headerField").getAsString()));
    if (json.has("_headerField"))
      parseElementProperties(json.getAsJsonObject("_headerField"), res.getHeaderFieldElement());
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(json.getAsJsonObject("_path"), res.getPathElement());
    if (json.has("sourceId"))
      res.setSourceIdElement(parseId(json.get("sourceId").getAsString()));
    if (json.has("_sourceId"))
      parseElementProperties(json.getAsJsonObject("_sourceId"), res.getSourceIdElement());
    return res;
  }

  protected TestScript.TestScriptSetupComponent parseTestScriptTestScriptSetupComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptSetupComponent res = new TestScript.TestScriptSetupComponent();
    parseBackboneProperties(json, res);
    if (json.has("metadata"))
      res.setMetadata(parseTestScriptTestScriptMetadataComponent(json.getAsJsonObject("metadata"), owner));
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseTestScriptTestScriptSetupActionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected TestScript.TestScriptSetupActionComponent parseTestScriptTestScriptSetupActionComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptSetupActionComponent res = new TestScript.TestScriptSetupActionComponent();
    parseBackboneProperties(json, res);
    if (json.has("operation"))
      res.setOperation(
          parseTestScriptTestScriptSetupActionOperationComponent(json.getAsJsonObject("operation"), owner));
    if (json.has("assert"))
      res.setAssert(parseTestScriptTestScriptSetupActionAssertComponent(json.getAsJsonObject("assert"), owner));
    return res;
  }

  protected TestScript.TestScriptSetupActionOperationComponent parseTestScriptTestScriptSetupActionOperationComponent(
      JsonObject json, TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptSetupActionOperationComponent res = new TestScript.TestScriptSetupActionOperationComponent();
    parseBackboneProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(json.getAsJsonObject("type")));
    if (json.has("resource"))
      res.setResourceElement(parseCode(json.get("resource").getAsString()));
    if (json.has("_resource"))
      parseElementProperties(json.getAsJsonObject("_resource"), res.getResourceElement());
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(json.getAsJsonObject("_label"), res.getLabelElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("accept"))
      res.setAcceptElement(parseEnumeration(json.get("accept").getAsString(), TestScript.ContentType.NULL,
          new TestScript.ContentTypeEnumFactory()));
    if (json.has("_accept"))
      parseElementProperties(json.getAsJsonObject("_accept"), res.getAcceptElement());
    if (json.has("contentType"))
      res.setContentTypeElement(parseEnumeration(json.get("contentType").getAsString(), TestScript.ContentType.NULL,
          new TestScript.ContentTypeEnumFactory()));
    if (json.has("_contentType"))
      parseElementProperties(json.getAsJsonObject("_contentType"), res.getContentTypeElement());
    if (json.has("destination"))
      res.setDestinationElement(parseInteger(json.get("destination").getAsLong()));
    if (json.has("_destination"))
      parseElementProperties(json.getAsJsonObject("_destination"), res.getDestinationElement());
    if (json.has("encodeRequestUrl"))
      res.setEncodeRequestUrlElement(parseBoolean(json.get("encodeRequestUrl").getAsBoolean()));
    if (json.has("_encodeRequestUrl"))
      parseElementProperties(json.getAsJsonObject("_encodeRequestUrl"), res.getEncodeRequestUrlElement());
    if (json.has("params"))
      res.setParamsElement(parseString(json.get("params").getAsString()));
    if (json.has("_params"))
      parseElementProperties(json.getAsJsonObject("_params"), res.getParamsElement());
    if (json.has("requestHeader")) {
      JsonArray array = json.getAsJsonArray("requestHeader");
      for (int i = 0; i < array.size(); i++) {
        res.getRequestHeader().add(
            parseTestScriptTestScriptSetupActionOperationRequestHeaderComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("responseId"))
      res.setResponseIdElement(parseId(json.get("responseId").getAsString()));
    if (json.has("_responseId"))
      parseElementProperties(json.getAsJsonObject("_responseId"), res.getResponseIdElement());
    if (json.has("sourceId"))
      res.setSourceIdElement(parseId(json.get("sourceId").getAsString()));
    if (json.has("_sourceId"))
      parseElementProperties(json.getAsJsonObject("_sourceId"), res.getSourceIdElement());
    if (json.has("targetId"))
      res.setTargetIdElement(parseId(json.get("targetId").getAsString()));
    if (json.has("_targetId"))
      parseElementProperties(json.getAsJsonObject("_targetId"), res.getTargetIdElement());
    if (json.has("url"))
      res.setUrlElement(parseString(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    return res;
  }

  protected TestScript.TestScriptSetupActionOperationRequestHeaderComponent parseTestScriptTestScriptSetupActionOperationRequestHeaderComponent(
      JsonObject json, TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptSetupActionOperationRequestHeaderComponent res = new TestScript.TestScriptSetupActionOperationRequestHeaderComponent();
    parseBackboneProperties(json, res);
    if (json.has("field"))
      res.setFieldElement(parseString(json.get("field").getAsString()));
    if (json.has("_field"))
      parseElementProperties(json.getAsJsonObject("_field"), res.getFieldElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected TestScript.TestScriptSetupActionAssertComponent parseTestScriptTestScriptSetupActionAssertComponent(
      JsonObject json, TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptSetupActionAssertComponent res = new TestScript.TestScriptSetupActionAssertComponent();
    parseBackboneProperties(json, res);
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(json.getAsJsonObject("_label"), res.getLabelElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("direction"))
      res.setDirectionElement(parseEnumeration(json.get("direction").getAsString(),
          TestScript.AssertionDirectionType.NULL, new TestScript.AssertionDirectionTypeEnumFactory()));
    if (json.has("_direction"))
      parseElementProperties(json.getAsJsonObject("_direction"), res.getDirectionElement());
    if (json.has("compareToSourceId"))
      res.setCompareToSourceIdElement(parseString(json.get("compareToSourceId").getAsString()));
    if (json.has("_compareToSourceId"))
      parseElementProperties(json.getAsJsonObject("_compareToSourceId"), res.getCompareToSourceIdElement());
    if (json.has("compareToSourcePath"))
      res.setCompareToSourcePathElement(parseString(json.get("compareToSourcePath").getAsString()));
    if (json.has("_compareToSourcePath"))
      parseElementProperties(json.getAsJsonObject("_compareToSourcePath"), res.getCompareToSourcePathElement());
    if (json.has("contentType"))
      res.setContentTypeElement(parseEnumeration(json.get("contentType").getAsString(), TestScript.ContentType.NULL,
          new TestScript.ContentTypeEnumFactory()));
    if (json.has("_contentType"))
      parseElementProperties(json.getAsJsonObject("_contentType"), res.getContentTypeElement());
    if (json.has("headerField"))
      res.setHeaderFieldElement(parseString(json.get("headerField").getAsString()));
    if (json.has("_headerField"))
      parseElementProperties(json.getAsJsonObject("_headerField"), res.getHeaderFieldElement());
    if (json.has("minimumId"))
      res.setMinimumIdElement(parseString(json.get("minimumId").getAsString()));
    if (json.has("_minimumId"))
      parseElementProperties(json.getAsJsonObject("_minimumId"), res.getMinimumIdElement());
    if (json.has("navigationLinks"))
      res.setNavigationLinksElement(parseBoolean(json.get("navigationLinks").getAsBoolean()));
    if (json.has("_navigationLinks"))
      parseElementProperties(json.getAsJsonObject("_navigationLinks"), res.getNavigationLinksElement());
    if (json.has("operator"))
      res.setOperatorElement(parseEnumeration(json.get("operator").getAsString(), TestScript.AssertionOperatorType.NULL,
          new TestScript.AssertionOperatorTypeEnumFactory()));
    if (json.has("_operator"))
      parseElementProperties(json.getAsJsonObject("_operator"), res.getOperatorElement());
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(json.getAsJsonObject("_path"), res.getPathElement());
    if (json.has("resource"))
      res.setResourceElement(parseCode(json.get("resource").getAsString()));
    if (json.has("_resource"))
      parseElementProperties(json.getAsJsonObject("_resource"), res.getResourceElement());
    if (json.has("response"))
      res.setResponseElement(parseEnumeration(json.get("response").getAsString(),
          TestScript.AssertionResponseTypes.NULL, new TestScript.AssertionResponseTypesEnumFactory()));
    if (json.has("_response"))
      parseElementProperties(json.getAsJsonObject("_response"), res.getResponseElement());
    if (json.has("responseCode"))
      res.setResponseCodeElement(parseString(json.get("responseCode").getAsString()));
    if (json.has("_responseCode"))
      parseElementProperties(json.getAsJsonObject("_responseCode"), res.getResponseCodeElement());
    if (json.has("sourceId"))
      res.setSourceIdElement(parseId(json.get("sourceId").getAsString()));
    if (json.has("_sourceId"))
      parseElementProperties(json.getAsJsonObject("_sourceId"), res.getSourceIdElement());
    if (json.has("validateProfileId"))
      res.setValidateProfileIdElement(parseId(json.get("validateProfileId").getAsString()));
    if (json.has("_validateProfileId"))
      parseElementProperties(json.getAsJsonObject("_validateProfileId"), res.getValidateProfileIdElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    if (json.has("warningOnly"))
      res.setWarningOnlyElement(parseBoolean(json.get("warningOnly").getAsBoolean()));
    if (json.has("_warningOnly"))
      parseElementProperties(json.getAsJsonObject("_warningOnly"), res.getWarningOnlyElement());
    return res;
  }

  protected TestScript.TestScriptTestComponent parseTestScriptTestScriptTestComponent(JsonObject json, TestScript owner)
      throws IOException, FHIRFormatError {
    TestScript.TestScriptTestComponent res = new TestScript.TestScriptTestComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("metadata"))
      res.setMetadata(parseTestScriptTestScriptMetadataComponent(json.getAsJsonObject("metadata"), owner));
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseTestScriptTestScriptTestActionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected TestScript.TestScriptTestActionComponent parseTestScriptTestScriptTestActionComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptTestActionComponent res = new TestScript.TestScriptTestActionComponent();
    parseBackboneProperties(json, res);
    if (json.has("operation"))
      res.setOperation(
          parseTestScriptTestScriptSetupActionOperationComponent(json.getAsJsonObject("operation"), owner));
    if (json.has("assert"))
      res.setAssert(parseTestScriptTestScriptSetupActionAssertComponent(json.getAsJsonObject("assert"), owner));
    return res;
  }

  protected TestScript.TestScriptTeardownComponent parseTestScriptTestScriptTeardownComponent(JsonObject json,
      TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptTeardownComponent res = new TestScript.TestScriptTeardownComponent();
    parseBackboneProperties(json, res);
    if (json.has("action")) {
      JsonArray array = json.getAsJsonArray("action");
      for (int i = 0; i < array.size(); i++) {
        res.getAction().add(parseTestScriptTestScriptTeardownActionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected TestScript.TestScriptTeardownActionComponent parseTestScriptTestScriptTeardownActionComponent(
      JsonObject json, TestScript owner) throws IOException, FHIRFormatError {
    TestScript.TestScriptTeardownActionComponent res = new TestScript.TestScriptTeardownActionComponent();
    parseBackboneProperties(json, res);
    if (json.has("operation"))
      res.setOperation(
          parseTestScriptTestScriptSetupActionOperationComponent(json.getAsJsonObject("operation"), owner));
    return res;
  }

  protected ValueSet parseValueSet(JsonObject json) throws IOException, FHIRFormatError {
    ValueSet res = new ValueSet();
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(json.getAsJsonObject("_url"), res.getUrlElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(json.getAsJsonObject("identifier")));
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(),
          Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(json.getAsJsonObject("_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(json.getAsJsonObject("_experimental"), res.getExperimentalElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(json.getAsJsonObject("_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = json.getAsJsonArray("contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseValueSetValueSetContactComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(json.getAsJsonObject("_date"), res.getDateElement());
    if (json.has("lockedDate"))
      res.setLockedDateElement(parseDate(json.get("lockedDate").getAsString()));
    if (json.has("_lockedDate"))
      parseElementProperties(json.getAsJsonObject("_lockedDate"), res.getLockedDateElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(json.getAsJsonObject("_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = json.getAsJsonArray("useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("immutable"))
      res.setImmutableElement(parseBoolean(json.get("immutable").getAsBoolean()));
    if (json.has("_immutable"))
      parseElementProperties(json.getAsJsonObject("_immutable"), res.getImmutableElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseString(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(json.getAsJsonObject("_requirements"), res.getRequirementsElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseString(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(json.getAsJsonObject("_copyright"), res.getCopyrightElement());
    if (json.has("extensible"))
      res.setExtensibleElement(parseBoolean(json.get("extensible").getAsBoolean()));
    if (json.has("_extensible"))
      parseElementProperties(json.getAsJsonObject("_extensible"), res.getExtensibleElement());
    if (json.has("codeSystem"))
      res.setCodeSystem(parseValueSetValueSetCodeSystemComponent(json.getAsJsonObject("codeSystem"), res));
    if (json.has("compose"))
      res.setCompose(parseValueSetValueSetComposeComponent(json.getAsJsonObject("compose"), res));
    if (json.has("expansion"))
      res.setExpansion(parseValueSetValueSetExpansionComponent(json.getAsJsonObject("expansion"), res));
    return res;
  }

  protected ValueSet.ValueSetContactComponent parseValueSetValueSetContactComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ValueSetContactComponent res = new ValueSet.ValueSetContactComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = json.getAsJsonArray("telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ValueSetCodeSystemComponent parseValueSetValueSetCodeSystemComponent(JsonObject json,
      ValueSet owner) throws IOException, FHIRFormatError {
    ValueSet.ValueSetCodeSystemComponent res = new ValueSet.ValueSetCodeSystemComponent();
    parseBackboneProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("caseSensitive"))
      res.setCaseSensitiveElement(parseBoolean(json.get("caseSensitive").getAsBoolean()));
    if (json.has("_caseSensitive"))
      parseElementProperties(json.getAsJsonObject("_caseSensitive"), res.getCaseSensitiveElement());
    if (json.has("concept")) {
      JsonArray array = json.getAsJsonArray("concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseValueSetConceptDefinitionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ConceptDefinitionComponent parseValueSetConceptDefinitionComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ConceptDefinitionComponent res = new ValueSet.ConceptDefinitionComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("abstract"))
      res.setAbstractElement(parseBoolean(json.get("abstract").getAsBoolean()));
    if (json.has("_abstract"))
      parseElementProperties(json.getAsJsonObject("_abstract"), res.getAbstractElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseString(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(json.getAsJsonObject("_definition"), res.getDefinitionElement());
    if (json.has("designation")) {
      JsonArray array = json.getAsJsonArray("designation");
      for (int i = 0; i < array.size(); i++) {
        res.getDesignation()
            .add(parseValueSetConceptDefinitionDesignationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("concept")) {
      JsonArray array = json.getAsJsonArray("concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseValueSetConceptDefinitionComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ConceptDefinitionDesignationComponent parseValueSetConceptDefinitionDesignationComponent(
      JsonObject json, ValueSet owner) throws IOException, FHIRFormatError {
    ValueSet.ConceptDefinitionDesignationComponent res = new ValueSet.ConceptDefinitionDesignationComponent();
    parseBackboneProperties(json, res);
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(json.getAsJsonObject("_language"), res.getLanguageElement());
    if (json.has("use"))
      res.setUse(parseCoding(json.getAsJsonObject("use")));
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ValueSet.ValueSetComposeComponent parseValueSetValueSetComposeComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ValueSetComposeComponent res = new ValueSet.ValueSetComposeComponent();
    parseBackboneProperties(json, res);
    if (json.has("import")) {
      JsonArray array = json.getAsJsonArray("import");
      for (int i = 0; i < array.size(); i++) {
        res.getImport().add(parseUri(array.get(i).getAsString()));
      }
    }
    ;
    if (json.has("_import")) {
      JsonArray array = json.getAsJsonArray("_import");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getImport().size())
          res.getImport().add(parseUri(null));
        if (array.get(i) instanceof JsonObject)
          parseElementProperties(array.get(i).getAsJsonObject(), res.getImport().get(i));
      }
    }
    ;
    if (json.has("include")) {
      JsonArray array = json.getAsJsonArray("include");
      for (int i = 0; i < array.size(); i++) {
        if (!array.get(i).isJsonNull()) {
          res.getInclude().add(parseValueSetConceptSetComponent(array.get(i).getAsJsonObject(), owner));
        }
      }
    }
    ;
    if (json.has("exclude")) {
      JsonArray array = json.getAsJsonArray("exclude");
      for (int i = 0; i < array.size(); i++) {
        res.getExclude().add(parseValueSetConceptSetComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ConceptSetComponent parseValueSetConceptSetComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ConceptSetComponent res = new ValueSet.ConceptSetComponent();
    parseBackboneProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("concept")) {
      JsonArray array = json.getAsJsonArray("concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseValueSetConceptReferenceComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("filter")) {
      JsonArray array = json.getAsJsonArray("filter");
      for (int i = 0; i < array.size(); i++) {
        res.getFilter().add(parseValueSetConceptSetFilterComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ConceptReferenceComponent parseValueSetConceptReferenceComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ConceptReferenceComponent res = new ValueSet.ConceptReferenceComponent();
    parseBackboneProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("designation")) {
      JsonArray array = json.getAsJsonArray("designation");
      for (int i = 0; i < array.size(); i++) {
        res.getDesignation()
            .add(parseValueSetConceptDefinitionDesignationComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ConceptSetFilterComponent parseValueSetConceptSetFilterComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ConceptSetFilterComponent res = new ValueSet.ConceptSetFilterComponent();
    parseBackboneProperties(json, res);
    if (json.has("property"))
      res.setPropertyElement(parseCode(json.get("property").getAsString()));
    if (json.has("_property"))
      parseElementProperties(json.getAsJsonObject("_property"), res.getPropertyElement());
    if (json.has("op"))
      res.setOpElement(parseEnumeration(json.get("op").getAsString(), ValueSet.FilterOperator.NULL,
          new ValueSet.FilterOperatorEnumFactory()));
    if (json.has("_op"))
      parseElementProperties(json.getAsJsonObject("_op"), res.getOpElement());
    if (json.has("value"))
      res.setValueElement(parseCode(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(json.getAsJsonObject("_value"), res.getValueElement());
    return res;
  }

  protected ValueSet.ValueSetExpansionComponent parseValueSetValueSetExpansionComponent(JsonObject json, ValueSet owner)
      throws IOException, FHIRFormatError {
    ValueSet.ValueSetExpansionComponent res = new ValueSet.ValueSetExpansionComponent();
    parseBackboneProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifierElement(parseUri(json.get("identifier").getAsString()));
    if (json.has("_identifier"))
      parseElementProperties(json.getAsJsonObject("_identifier"), res.getIdentifierElement());
    if (json.has("timestamp"))
      res.setTimestampElement(parseDateTime(json.get("timestamp").getAsString()));
    if (json.has("_timestamp"))
      parseElementProperties(json.getAsJsonObject("_timestamp"), res.getTimestampElement());
    if (json.has("total"))
      res.setTotalElement(parseInteger(json.get("total").getAsLong()));
    if (json.has("_total"))
      parseElementProperties(json.getAsJsonObject("_total"), res.getTotalElement());
    if (json.has("offset"))
      res.setOffsetElement(parseInteger(json.get("offset").getAsLong()));
    if (json.has("_offset"))
      parseElementProperties(json.getAsJsonObject("_offset"), res.getOffsetElement());
    if (json.has("parameter")) {
      JsonArray array = json.getAsJsonArray("parameter");
      for (int i = 0; i < array.size(); i++) {
        res.getParameter().add(parseValueSetValueSetExpansionParameterComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    if (json.has("contains")) {
      JsonArray array = json.getAsJsonArray("contains");
      for (int i = 0; i < array.size(); i++) {
        res.getContains().add(parseValueSetValueSetExpansionContainsComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected ValueSet.ValueSetExpansionParameterComponent parseValueSetValueSetExpansionParameterComponent(
      JsonObject json, ValueSet owner) throws IOException, FHIRFormatError {
    ValueSet.ValueSetExpansionParameterComponent res = new ValueSet.ValueSetExpansionParameterComponent();
    parseBackboneProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(json.getAsJsonObject("_name"), res.getNameElement());
    Type value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    return res;
  }

  protected ValueSet.ValueSetExpansionContainsComponent parseValueSetValueSetExpansionContainsComponent(JsonObject json,
      ValueSet owner) throws IOException, FHIRFormatError {
    ValueSet.ValueSetExpansionContainsComponent res = new ValueSet.ValueSetExpansionContainsComponent();
    parseBackboneProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseUri(json.get("system").getAsString()));
    if (json.has("_system"))
      parseElementProperties(json.getAsJsonObject("_system"), res.getSystemElement());
    if (json.has("abstract"))
      res.setAbstractElement(parseBoolean(json.get("abstract").getAsBoolean()));
    if (json.has("_abstract"))
      parseElementProperties(json.getAsJsonObject("_abstract"), res.getAbstractElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(json.getAsJsonObject("_version"), res.getVersionElement());
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(json.getAsJsonObject("_code"), res.getCodeElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(json.getAsJsonObject("_display"), res.getDisplayElement());
    if (json.has("contains")) {
      JsonArray array = json.getAsJsonArray("contains");
      for (int i = 0; i < array.size(); i++) {
        res.getContains().add(parseValueSetValueSetExpansionContainsComponent(array.get(i).getAsJsonObject(), owner));
      }
    }
    ;
    return res;
  }

  protected VisionPrescription parseVisionPrescription(JsonObject json) throws IOException, FHIRFormatError {
    VisionPrescription res = new VisionPrescription();
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = json.getAsJsonArray("identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    }
    ;
    if (json.has("dateWritten"))
      res.setDateWrittenElement(parseDateTime(json.get("dateWritten").getAsString()));
    if (json.has("_dateWritten"))
      parseElementProperties(json.getAsJsonObject("_dateWritten"), res.getDateWrittenElement());
    if (json.has("patient"))
      res.setPatient(parseReference(json.getAsJsonObject("patient")));
    if (json.has("prescriber"))
      res.setPrescriber(parseReference(json.getAsJsonObject("prescriber")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(json.getAsJsonObject("encounter")));
    Type reason = parseType("reason", json);
    if (reason != null)
      res.setReason(reason);
    if (json.has("dispense")) {
      JsonArray array = json.getAsJsonArray("dispense");
      for (int i = 0; i < array.size(); i++) {
        res.getDispense()
            .add(parseVisionPrescriptionVisionPrescriptionDispenseComponent(array.get(i).getAsJsonObject(), res));
      }
    }
    ;
    return res;
  }

  protected VisionPrescription.VisionPrescriptionDispenseComponent parseVisionPrescriptionVisionPrescriptionDispenseComponent(
      JsonObject json, VisionPrescription owner) throws IOException, FHIRFormatError {
    VisionPrescription.VisionPrescriptionDispenseComponent res = new VisionPrescription.VisionPrescriptionDispenseComponent();
    parseBackboneProperties(json, res);
    if (json.has("product"))
      res.setProduct(parseCoding(json.getAsJsonObject("product")));
    if (json.has("eye"))
      res.setEyeElement(parseEnumeration(json.get("eye").getAsString(), VisionPrescription.VisionEyes.NULL,
          new VisionPrescription.VisionEyesEnumFactory()));
    if (json.has("_eye"))
      parseElementProperties(json.getAsJsonObject("_eye"), res.getEyeElement());
    if (json.has("sphere"))
      res.setSphereElement(parseDecimal(json.get("sphere").getAsBigDecimal()));
    if (json.has("_sphere"))
      parseElementProperties(json.getAsJsonObject("_sphere"), res.getSphereElement());
    if (json.has("cylinder"))
      res.setCylinderElement(parseDecimal(json.get("cylinder").getAsBigDecimal()));
    if (json.has("_cylinder"))
      parseElementProperties(json.getAsJsonObject("_cylinder"), res.getCylinderElement());
    if (json.has("axis"))
      res.setAxisElement(parseInteger(json.get("axis").getAsLong()));
    if (json.has("_axis"))
      parseElementProperties(json.getAsJsonObject("_axis"), res.getAxisElement());
    if (json.has("prism"))
      res.setPrismElement(parseDecimal(json.get("prism").getAsBigDecimal()));
    if (json.has("_prism"))
      parseElementProperties(json.getAsJsonObject("_prism"), res.getPrismElement());
    if (json.has("base"))
      res.setBaseElement(parseEnumeration(json.get("base").getAsString(), VisionPrescription.VisionBase.NULL,
          new VisionPrescription.VisionBaseEnumFactory()));
    if (json.has("_base"))
      parseElementProperties(json.getAsJsonObject("_base"), res.getBaseElement());
    if (json.has("add"))
      res.setAddElement(parseDecimal(json.get("add").getAsBigDecimal()));
    if (json.has("_add"))
      parseElementProperties(json.getAsJsonObject("_add"), res.getAddElement());
    if (json.has("power"))
      res.setPowerElement(parseDecimal(json.get("power").getAsBigDecimal()));
    if (json.has("_power"))
      parseElementProperties(json.getAsJsonObject("_power"), res.getPowerElement());
    if (json.has("backCurve"))
      res.setBackCurveElement(parseDecimal(json.get("backCurve").getAsBigDecimal()));
    if (json.has("_backCurve"))
      parseElementProperties(json.getAsJsonObject("_backCurve"), res.getBackCurveElement());
    if (json.has("diameter"))
      res.setDiameterElement(parseDecimal(json.get("diameter").getAsBigDecimal()));
    if (json.has("_diameter"))
      parseElementProperties(json.getAsJsonObject("_diameter"), res.getDiameterElement());
    if (json.has("duration"))
      res.setDuration(parseSimpleQuantity(json.getAsJsonObject("duration")));
    if (json.has("color"))
      res.setColorElement(parseString(json.get("color").getAsString()));
    if (json.has("_color"))
      parseElementProperties(json.getAsJsonObject("_color"), res.getColorElement());
    if (json.has("brand"))
      res.setBrandElement(parseString(json.get("brand").getAsString()));
    if (json.has("_brand"))
      parseElementProperties(json.getAsJsonObject("_brand"), res.getBrandElement());
    if (json.has("notes"))
      res.setNotesElement(parseString(json.get("notes").getAsString()));
    if (json.has("_notes"))
      parseElementProperties(json.getAsJsonObject("_notes"), res.getNotesElement());
    return res;
  }

  @Override
  protected Resource parseResource(JsonObject json) throws IOException, FHIRFormatError {
    if (!json.has("resourceType")) {
      throw new FHIRFormatError("Unable to find resource type - maybe not a FHIR resource?");
    }
    String t = json.get("resourceType").getAsString();
    if (Utilities.noString(t))
      throw new FHIRFormatError("Unable to find resource type - maybe not a FHIR resource?");
    if (t.equals("Parameters"))
      return parseParameters(json);
    else if (t.equals("Account"))
      return parseAccount(json);
    else if (t.equals("AllergyIntolerance"))
      return parseAllergyIntolerance(json);
    else if (t.equals("Appointment"))
      return parseAppointment(json);
    else if (t.equals("AppointmentResponse"))
      return parseAppointmentResponse(json);
    else if (t.equals("AuditEvent"))
      return parseAuditEvent(json);
    else if (t.equals("Basic"))
      return parseBasic(json);
    else if (t.equals("Binary"))
      return parseBinary(json);
    else if (t.equals("BodySite"))
      return parseBodySite(json);
    else if (t.equals("Bundle"))
      return parseBundle(json);
    else if (t.equals("CarePlan"))
      return parseCarePlan(json);
    else if (t.equals("Claim"))
      return parseClaim(json);
    else if (t.equals("ClaimResponse"))
      return parseClaimResponse(json);
    else if (t.equals("ClinicalImpression"))
      return parseClinicalImpression(json);
    else if (t.equals("Communication"))
      return parseCommunication(json);
    else if (t.equals("CommunicationRequest"))
      return parseCommunicationRequest(json);
    else if (t.equals("Composition"))
      return parseComposition(json);
    else if (t.equals("ConceptMap"))
      return parseConceptMap(json);
    else if (t.equals("Condition"))
      return parseCondition(json);
    else if (t.equals("Conformance"))
      return parseConformance(json);
    else if (t.equals("Contract"))
      return parseContract(json);
    else if (t.equals("Coverage"))
      return parseCoverage(json);
    else if (t.equals("DataElement"))
      return parseDataElement(json);
    else if (t.equals("DetectedIssue"))
      return parseDetectedIssue(json);
    else if (t.equals("Device"))
      return parseDevice(json);
    else if (t.equals("DeviceComponent"))
      return parseDeviceComponent(json);
    else if (t.equals("DeviceMetric"))
      return parseDeviceMetric(json);
    else if (t.equals("DeviceUseRequest"))
      return parseDeviceUseRequest(json);
    else if (t.equals("DeviceUseStatement"))
      return parseDeviceUseStatement(json);
    else if (t.equals("DiagnosticOrder"))
      return parseDiagnosticOrder(json);
    else if (t.equals("DiagnosticReport"))
      return parseDiagnosticReport(json);
    else if (t.equals("DocumentManifest"))
      return parseDocumentManifest(json);
    else if (t.equals("DocumentReference"))
      return parseDocumentReference(json);
    else if (t.equals("EligibilityRequest"))
      return parseEligibilityRequest(json);
    else if (t.equals("EligibilityResponse"))
      return parseEligibilityResponse(json);
    else if (t.equals("Encounter"))
      return parseEncounter(json);
    else if (t.equals("EnrollmentRequest"))
      return parseEnrollmentRequest(json);
    else if (t.equals("EnrollmentResponse"))
      return parseEnrollmentResponse(json);
    else if (t.equals("EpisodeOfCare"))
      return parseEpisodeOfCare(json);
    else if (t.equals("ExplanationOfBenefit"))
      return parseExplanationOfBenefit(json);
    else if (t.equals("FamilyMemberHistory"))
      return parseFamilyMemberHistory(json);
    else if (t.equals("Flag"))
      return parseFlag(json);
    else if (t.equals("Goal"))
      return parseGoal(json);
    else if (t.equals("Group"))
      return parseGroup(json);
    else if (t.equals("HealthcareService"))
      return parseHealthcareService(json);
    else if (t.equals("ImagingObjectSelection"))
      return parseImagingObjectSelection(json);
    else if (t.equals("ImagingStudy"))
      return parseImagingStudy(json);
    else if (t.equals("Immunization"))
      return parseImmunization(json);
    else if (t.equals("ImmunizationRecommendation"))
      return parseImmunizationRecommendation(json);
    else if (t.equals("ImplementationGuide"))
      return parseImplementationGuide(json);
    else if (t.equals("List"))
      return parseList_(json);
    else if (t.equals("Location"))
      return parseLocation(json);
    else if (t.equals("Media"))
      return parseMedia(json);
    else if (t.equals("Medication"))
      return parseMedication(json);
    else if (t.equals("MedicationAdministration"))
      return parseMedicationAdministration(json);
    else if (t.equals("MedicationDispense"))
      return parseMedicationDispense(json);
    else if (t.equals("MedicationOrder"))
      return parseMedicationOrder(json);
    else if (t.equals("MedicationStatement"))
      return parseMedicationStatement(json);
    else if (t.equals("MessageHeader"))
      return parseMessageHeader(json);
    else if (t.equals("NamingSystem"))
      return parseNamingSystem(json);
    else if (t.equals("NutritionOrder"))
      return parseNutritionOrder(json);
    else if (t.equals("Observation"))
      return parseObservation(json);
    else if (t.equals("OperationDefinition"))
      return parseOperationDefinition(json);
    else if (t.equals("OperationOutcome"))
      return parseOperationOutcome(json);
    else if (t.equals("Order"))
      return parseOrder(json);
    else if (t.equals("OrderResponse"))
      return parseOrderResponse(json);
    else if (t.equals("Organization"))
      return parseOrganization(json);
    else if (t.equals("Patient"))
      return parsePatient(json);
    else if (t.equals("PaymentNotice"))
      return parsePaymentNotice(json);
    else if (t.equals("PaymentReconciliation"))
      return parsePaymentReconciliation(json);
    else if (t.equals("Person"))
      return parsePerson(json);
    else if (t.equals("Practitioner"))
      return parsePractitioner(json);
    else if (t.equals("Procedure"))
      return parseProcedure(json);
    else if (t.equals("ProcedureRequest"))
      return parseProcedureRequest(json);
    else if (t.equals("ProcessRequest"))
      return parseProcessRequest(json);
    else if (t.equals("ProcessResponse"))
      return parseProcessResponse(json);
    else if (t.equals("Provenance"))
      return parseProvenance(json);
    else if (t.equals("Questionnaire"))
      return parseQuestionnaire(json);
    else if (t.equals("QuestionnaireResponse"))
      return parseQuestionnaireResponse(json);
    else if (t.equals("ReferralRequest"))
      return parseReferralRequest(json);
    else if (t.equals("RelatedPerson"))
      return parseRelatedPerson(json);
    else if (t.equals("RiskAssessment"))
      return parseRiskAssessment(json);
    else if (t.equals("Schedule"))
      return parseSchedule(json);
    else if (t.equals("SearchParameter"))
      return parseSearchParameter(json);
    else if (t.equals("Slot"))
      return parseSlot(json);
    else if (t.equals("Specimen"))
      return parseSpecimen(json);
    else if (t.equals("StructureDefinition"))
      return parseStructureDefinition(json);
    else if (t.equals("Subscription"))
      return parseSubscription(json);
    else if (t.equals("Substance"))
      return parseSubstance(json);
    else if (t.equals("SupplyDelivery"))
      return parseSupplyDelivery(json);
    else if (t.equals("SupplyRequest"))
      return parseSupplyRequest(json);
    else if (t.equals("TestScript"))
      return parseTestScript(json);
    else if (t.equals("ValueSet"))
      return parseValueSet(json);
    else if (t.equals("VisionPrescription"))
      return parseVisionPrescription(json);
    else if (t.equals("Binary"))
      return parseBinary(json);
    throw new FHIRFormatError("Unknown.Unrecognised resource type '" + t + "' (in property 'resourceType')");
  }

  protected Type parseType(String prefix, JsonObject json) throws IOException, FHIRFormatError {
    if (json.has(prefix + "Identifier"))
      return parseIdentifier(json.getAsJsonObject(prefix + "Identifier"));
    else if (json.has(prefix + "Coding"))
      return parseCoding(json.getAsJsonObject(prefix + "Coding"));
    else if (json.has(prefix + "Reference"))
      return parseReference(json.getAsJsonObject(prefix + "Reference"));
    else if (json.has(prefix + "Signature"))
      return parseSignature(json.getAsJsonObject(prefix + "Signature"));
    else if (json.has(prefix + "SampledData"))
      return parseSampledData(json.getAsJsonObject(prefix + "SampledData"));
    else if (json.has(prefix + "Quantity"))
      return parseQuantity(json.getAsJsonObject(prefix + "Quantity"));
    else if (json.has(prefix + "Period"))
      return parsePeriod(json.getAsJsonObject(prefix + "Period"));
    else if (json.has(prefix + "Attachment"))
      return parseAttachment(json.getAsJsonObject(prefix + "Attachment"));
    else if (json.has(prefix + "Ratio"))
      return parseRatio(json.getAsJsonObject(prefix + "Ratio"));
    else if (json.has(prefix + "Range"))
      return parseRange(json.getAsJsonObject(prefix + "Range"));
    else if (json.has(prefix + "Annotation"))
      return parseAnnotation(json.getAsJsonObject(prefix + "Annotation"));
    else if (json.has(prefix + "CodeableConcept"))
      return parseCodeableConcept(json.getAsJsonObject(prefix + "CodeableConcept"));
    else if (json.has(prefix + "Money"))
      return parseMoney(json.getAsJsonObject(prefix + "Money"));
    else if (json.has(prefix + "SimpleQuantity"))
      return parseSimpleQuantity(json.getAsJsonObject(prefix + "SimpleQuantity"));
    else if (json.has(prefix + "Duration"))
      return parseDuration(json.getAsJsonObject(prefix + "Duration"));
    else if (json.has(prefix + "Count"))
      return parseCount(json.getAsJsonObject(prefix + "Count"));
    else if (json.has(prefix + "Distance"))
      return parseDistance(json.getAsJsonObject(prefix + "Distance"));
    else if (json.has(prefix + "Age"))
      return parseAge(json.getAsJsonObject(prefix + "Age"));
    else if (json.has(prefix + "HumanName"))
      return parseHumanName(json.getAsJsonObject(prefix + "HumanName"));
    else if (json.has(prefix + "ContactPoint"))
      return parseContactPoint(json.getAsJsonObject(prefix + "ContactPoint"));
    else if (json.has(prefix + "Meta"))
      return parseMeta(json.getAsJsonObject(prefix + "Meta"));
    else if (json.has(prefix + "Address"))
      return parseAddress(json.getAsJsonObject(prefix + "Address"));
    else if (json.has(prefix + "Timing"))
      return parseTiming(json.getAsJsonObject(prefix + "Timing"));
    else if (json.has(prefix + "ElementDefinition"))
      return parseElementDefinition(json.getAsJsonObject(prefix + "ElementDefinition"));
    else if (json.has(prefix + "Date") || json.has("_" + prefix + "Date")) {
      Type t = json.has(prefix + "Date") ? parseDate(json.get(prefix + "Date").getAsString()) : new DateType();
      if (json.has("_" + prefix + "Date"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Date"), t);
      return t;
    } else if (json.has(prefix + "DateTime") || json.has("_" + prefix + "DateTime")) {
      Type t = json.has(prefix + "DateTime") ? parseDateTime(json.get(prefix + "DateTime").getAsString())
          : new DateTimeType();
      if (json.has("_" + prefix + "DateTime"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "DateTime"), t);
      return t;
    } else if (json.has(prefix + "Code") || json.has("_" + prefix + "Code")) {
      Type t = json.has(prefix + "Code") ? parseCode(json.get(prefix + "Code").getAsString()) : new CodeType();
      if (json.has("_" + prefix + "Code"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Code"), t);
      return t;
    } else if (json.has(prefix + "String") || json.has("_" + prefix + "String")) {
      Type t = json.has(prefix + "String") ? parseString(json.get(prefix + "String").getAsString()) : new StringType();
      if (json.has("_" + prefix + "String"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "String"), t);
      return t;
    } else if (json.has(prefix + "Integer") || json.has("_" + prefix + "Integer")) {
      Type t = json.has(prefix + "Integer") ? parseInteger(json.get(prefix + "Integer").getAsLong())
          : new IntegerType();
      if (json.has("_" + prefix + "Integer"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Integer"), t);
      return t;
    } else if (json.has(prefix + "Oid") || json.has("_" + prefix + "Oid")) {
      Type t = json.has(prefix + "Oid") ? parseOid(json.get(prefix + "Oid").getAsString()) : new OidType();
      if (json.has("_" + prefix + "Oid"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Oid"), t);
      return t;
    } else if (json.has(prefix + "Uri") || json.has("_" + prefix + "Uri")) {
      Type t = json.has(prefix + "Uri") ? parseUri(json.get(prefix + "Uri").getAsString()) : new UriType();
      if (json.has("_" + prefix + "Uri"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Uri"), t);
      return t;
    } else if (json.has(prefix + "Uuid") || json.has("_" + prefix + "Uuid")) {
      Type t = json.has(prefix + "Uuid") ? parseUuid(json.get(prefix + "Uuid").getAsString()) : new UuidType();
      if (json.has("_" + prefix + "Uuid"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Uuid"), t);
      return t;
    } else if (json.has(prefix + "Instant") || json.has("_" + prefix + "Instant")) {
      Type t = json.has(prefix + "Instant") ? parseInstant(json.get(prefix + "Instant").getAsString())
          : new InstantType();
      if (json.has("_" + prefix + "Instant"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Instant"), t);
      return t;
    } else if (json.has(prefix + "Boolean") || json.has("_" + prefix + "Boolean")) {
      Type t = json.has(prefix + "Boolean") ? parseBoolean(json.get(prefix + "Boolean").getAsBoolean())
          : new BooleanType();
      if (json.has("_" + prefix + "Boolean"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Boolean"), t);
      return t;
    } else if (json.has(prefix + "Base64Binary") || json.has("_" + prefix + "Base64Binary")) {
      Type t = json.has(prefix + "Base64Binary") ? parseBase64Binary(json.get(prefix + "Base64Binary").getAsString())
          : new Base64BinaryType();
      if (json.has("_" + prefix + "Base64Binary"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Base64Binary"), t);
      return t;
    } else if (json.has(prefix + "UnsignedInt") || json.has("_" + prefix + "UnsignedInt")) {
      Type t = json.has(prefix + "UnsignedInt") ? parseUnsignedInt(json.get(prefix + "UnsignedInt").getAsString())
          : new UnsignedIntType();
      if (json.has("_" + prefix + "UnsignedInt"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "UnsignedInt"), t);
      return t;
    } else if (json.has(prefix + "Markdown") || json.has("_" + prefix + "Markdown")) {
      Type t = json.has(prefix + "Markdown") ? parseMarkdown(json.get(prefix + "Markdown").getAsString())
          : new MarkdownType();
      if (json.has("_" + prefix + "Markdown"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Markdown"), t);
      return t;
    } else if (json.has(prefix + "Time") || json.has("_" + prefix + "Time")) {
      Type t = json.has(prefix + "Time") ? parseTime(json.get(prefix + "Time").getAsString()) : new TimeType();
      if (json.has("_" + prefix + "Time"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Time"), t);
      return t;
    } else if (json.has(prefix + "Id") || json.has("_" + prefix + "Id")) {
      Type t = json.has(prefix + "Id") ? parseId(json.get(prefix + "Id").getAsString()) : new IdType();
      if (json.has("_" + prefix + "Id"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Id"), t);
      return t;
    } else if (json.has(prefix + "PositiveInt") || json.has("_" + prefix + "PositiveInt")) {
      Type t = json.has(prefix + "PositiveInt") ? parsePositiveInt(json.get(prefix + "PositiveInt").getAsString())
          : new PositiveIntType();
      if (json.has("_" + prefix + "PositiveInt"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "PositiveInt"), t);
      return t;
    } else if (json.has(prefix + "Decimal") || json.has("_" + prefix + "Decimal")) {
      Type t = json.has(prefix + "Decimal") ? parseDecimal(json.get(prefix + "Decimal").getAsBigDecimal())
          : new DecimalType();
      if (json.has("_" + prefix + "Decimal"))
        parseElementProperties(json.getAsJsonObject("_" + prefix + "Decimal"), t);
      return t;
    }
    return null;
  }

  protected Type parseType(JsonObject json, String type) throws IOException, FHIRFormatError {
    if (type.equals("Identifier"))
      return parseIdentifier(json);
    else if (type.equals("Coding"))
      return parseCoding(json);
    else if (type.equals("Reference"))
      return parseReference(json);
    else if (type.equals("Signature"))
      return parseSignature(json);
    else if (type.equals("SampledData"))
      return parseSampledData(json);
    else if (type.equals("Quantity"))
      return parseQuantity(json);
    else if (type.equals("Period"))
      return parsePeriod(json);
    else if (type.equals("Attachment"))
      return parseAttachment(json);
    else if (type.equals("Ratio"))
      return parseRatio(json);
    else if (type.equals("Range"))
      return parseRange(json);
    else if (type.equals("Annotation"))
      return parseAnnotation(json);
    else if (type.equals("CodeableConcept"))
      return parseCodeableConcept(json);
    else if (type.equals("Money"))
      return parseMoney(json);
    else if (type.equals("SimpleQuantity"))
      return parseSimpleQuantity(json);
    else if (type.equals("Duration"))
      return parseDuration(json);
    else if (type.equals("Count"))
      return parseCount(json);
    else if (type.equals("Distance"))
      return parseDistance(json);
    else if (type.equals("Age"))
      return parseAge(json);
    else if (type.equals("HumanName"))
      return parseHumanName(json);
    else if (type.equals("ContactPoint"))
      return parseContactPoint(json);
    else if (type.equals("Meta"))
      return parseMeta(json);
    else if (type.equals("Address"))
      return parseAddress(json);
    else if (type.equals("Timing"))
      return parseTiming(json);
    else if (type.equals("ElementDefinition"))
      return parseElementDefinition(json);
    throw new FHIRFormatError("Unknown Type " + type);
  }

  protected boolean hasTypeName(JsonObject json, String prefix) {
    if (json.has(prefix + "Identifier"))
      return true;
    if (json.has(prefix + "Coding"))
      return true;
    if (json.has(prefix + "Reference"))
      return true;
    if (json.has(prefix + "Signature"))
      return true;
    if (json.has(prefix + "SampledData"))
      return true;
    if (json.has(prefix + "Quantity"))
      return true;
    if (json.has(prefix + "Period"))
      return true;
    if (json.has(prefix + "Attachment"))
      return true;
    if (json.has(prefix + "Ratio"))
      return true;
    if (json.has(prefix + "Range"))
      return true;
    if (json.has(prefix + "Annotation"))
      return true;
    if (json.has(prefix + "CodeableConcept"))
      return true;
    if (json.has(prefix + "Money"))
      return true;
    if (json.has(prefix + "SimpleQuantity"))
      return true;
    if (json.has(prefix + "Duration"))
      return true;
    if (json.has(prefix + "Count"))
      return true;
    if (json.has(prefix + "Distance"))
      return true;
    if (json.has(prefix + "Age"))
      return true;
    if (json.has(prefix + "HumanName"))
      return true;
    if (json.has(prefix + "ContactPoint"))
      return true;
    if (json.has(prefix + "Meta"))
      return true;
    if (json.has(prefix + "Address"))
      return true;
    if (json.has(prefix + "Timing"))
      return true;
    if (json.has(prefix + "ElementDefinition"))
      return true;
    if (json.has(prefix + "Parameters"))
      return true;
    if (json.has(prefix + "Account"))
      return true;
    if (json.has(prefix + "AllergyIntolerance"))
      return true;
    if (json.has(prefix + "Appointment"))
      return true;
    if (json.has(prefix + "AppointmentResponse"))
      return true;
    if (json.has(prefix + "AuditEvent"))
      return true;
    if (json.has(prefix + "Basic"))
      return true;
    if (json.has(prefix + "Binary"))
      return true;
    if (json.has(prefix + "BodySite"))
      return true;
    if (json.has(prefix + "Bundle"))
      return true;
    if (json.has(prefix + "CarePlan"))
      return true;
    if (json.has(prefix + "Claim"))
      return true;
    if (json.has(prefix + "ClaimResponse"))
      return true;
    if (json.has(prefix + "ClinicalImpression"))
      return true;
    if (json.has(prefix + "Communication"))
      return true;
    if (json.has(prefix + "CommunicationRequest"))
      return true;
    if (json.has(prefix + "Composition"))
      return true;
    if (json.has(prefix + "ConceptMap"))
      return true;
    if (json.has(prefix + "Condition"))
      return true;
    if (json.has(prefix + "Conformance"))
      return true;
    if (json.has(prefix + "Contract"))
      return true;
    if (json.has(prefix + "Coverage"))
      return true;
    if (json.has(prefix + "DataElement"))
      return true;
    if (json.has(prefix + "DetectedIssue"))
      return true;
    if (json.has(prefix + "Device"))
      return true;
    if (json.has(prefix + "DeviceComponent"))
      return true;
    if (json.has(prefix + "DeviceMetric"))
      return true;
    if (json.has(prefix + "DeviceUseRequest"))
      return true;
    if (json.has(prefix + "DeviceUseStatement"))
      return true;
    if (json.has(prefix + "DiagnosticOrder"))
      return true;
    if (json.has(prefix + "DiagnosticReport"))
      return true;
    if (json.has(prefix + "DocumentManifest"))
      return true;
    if (json.has(prefix + "DocumentReference"))
      return true;
    if (json.has(prefix + "EligibilityRequest"))
      return true;
    if (json.has(prefix + "EligibilityResponse"))
      return true;
    if (json.has(prefix + "Encounter"))
      return true;
    if (json.has(prefix + "EnrollmentRequest"))
      return true;
    if (json.has(prefix + "EnrollmentResponse"))
      return true;
    if (json.has(prefix + "EpisodeOfCare"))
      return true;
    if (json.has(prefix + "ExplanationOfBenefit"))
      return true;
    if (json.has(prefix + "FamilyMemberHistory"))
      return true;
    if (json.has(prefix + "Flag"))
      return true;
    if (json.has(prefix + "Goal"))
      return true;
    if (json.has(prefix + "Group"))
      return true;
    if (json.has(prefix + "HealthcareService"))
      return true;
    if (json.has(prefix + "ImagingObjectSelection"))
      return true;
    if (json.has(prefix + "ImagingStudy"))
      return true;
    if (json.has(prefix + "Immunization"))
      return true;
    if (json.has(prefix + "ImmunizationRecommendation"))
      return true;
    if (json.has(prefix + "ImplementationGuide"))
      return true;
    if (json.has(prefix + "List"))
      return true;
    if (json.has(prefix + "Location"))
      return true;
    if (json.has(prefix + "Media"))
      return true;
    if (json.has(prefix + "Medication"))
      return true;
    if (json.has(prefix + "MedicationAdministration"))
      return true;
    if (json.has(prefix + "MedicationDispense"))
      return true;
    if (json.has(prefix + "MedicationOrder"))
      return true;
    if (json.has(prefix + "MedicationStatement"))
      return true;
    if (json.has(prefix + "MessageHeader"))
      return true;
    if (json.has(prefix + "NamingSystem"))
      return true;
    if (json.has(prefix + "NutritionOrder"))
      return true;
    if (json.has(prefix + "Observation"))
      return true;
    if (json.has(prefix + "OperationDefinition"))
      return true;
    if (json.has(prefix + "OperationOutcome"))
      return true;
    if (json.has(prefix + "Order"))
      return true;
    if (json.has(prefix + "OrderResponse"))
      return true;
    if (json.has(prefix + "Organization"))
      return true;
    if (json.has(prefix + "Patient"))
      return true;
    if (json.has(prefix + "PaymentNotice"))
      return true;
    if (json.has(prefix + "PaymentReconciliation"))
      return true;
    if (json.has(prefix + "Person"))
      return true;
    if (json.has(prefix + "Practitioner"))
      return true;
    if (json.has(prefix + "Procedure"))
      return true;
    if (json.has(prefix + "ProcedureRequest"))
      return true;
    if (json.has(prefix + "ProcessRequest"))
      return true;
    if (json.has(prefix + "ProcessResponse"))
      return true;
    if (json.has(prefix + "Provenance"))
      return true;
    if (json.has(prefix + "Questionnaire"))
      return true;
    if (json.has(prefix + "QuestionnaireResponse"))
      return true;
    if (json.has(prefix + "ReferralRequest"))
      return true;
    if (json.has(prefix + "RelatedPerson"))
      return true;
    if (json.has(prefix + "RiskAssessment"))
      return true;
    if (json.has(prefix + "Schedule"))
      return true;
    if (json.has(prefix + "SearchParameter"))
      return true;
    if (json.has(prefix + "Slot"))
      return true;
    if (json.has(prefix + "Specimen"))
      return true;
    if (json.has(prefix + "StructureDefinition"))
      return true;
    if (json.has(prefix + "Subscription"))
      return true;
    if (json.has(prefix + "Substance"))
      return true;
    if (json.has(prefix + "SupplyDelivery"))
      return true;
    if (json.has(prefix + "SupplyRequest"))
      return true;
    if (json.has(prefix + "TestScript"))
      return true;
    if (json.has(prefix + "ValueSet"))
      return true;
    if (json.has(prefix + "VisionPrescription"))
      return true;
    if (json.has(prefix + "Date") || json.has("_" + prefix + "Date"))
      return true;
    if (json.has(prefix + "DateTime") || json.has("_" + prefix + "DateTime"))
      return true;
    if (json.has(prefix + "Code") || json.has("_" + prefix + "Code"))
      return true;
    if (json.has(prefix + "String") || json.has("_" + prefix + "String"))
      return true;
    if (json.has(prefix + "Integer") || json.has("_" + prefix + "Integer"))
      return true;
    if (json.has(prefix + "Oid") || json.has("_" + prefix + "Oid"))
      return true;
    if (json.has(prefix + "Uri") || json.has("_" + prefix + "Uri"))
      return true;
    if (json.has(prefix + "Uuid") || json.has("_" + prefix + "Uuid"))
      return true;
    if (json.has(prefix + "Instant") || json.has("_" + prefix + "Instant"))
      return true;
    if (json.has(prefix + "Boolean") || json.has("_" + prefix + "Boolean"))
      return true;
    if (json.has(prefix + "Base64Binary") || json.has("_" + prefix + "Base64Binary"))
      return true;
    if (json.has(prefix + "UnsignedInt") || json.has("_" + prefix + "UnsignedInt"))
      return true;
    if (json.has(prefix + "Markdown") || json.has("_" + prefix + "Markdown"))
      return true;
    if (json.has(prefix + "Time") || json.has("_" + prefix + "Time"))
      return true;
    if (json.has(prefix + "Id") || json.has("_" + prefix + "Id"))
      return true;
    if (json.has(prefix + "PositiveInt") || json.has("_" + prefix + "PositiveInt"))
      return true;
    if (json.has(prefix + "Decimal") || json.has("_" + prefix + "Decimal"))
      return true;
    return false;
  }

  protected void composeElement(Element element) throws IOException {
    if (element.hasId())
      prop("id", element.getId());
    if (makeComments(element)) {
      openArray("fhir_comments");
      for (String s : element.getFormatCommentsPre())
        prop(null, s);
      for (String s : element.getFormatCommentsPost())
        prop(null, s);
      closeArray();
    }
    if (element.hasExtension()) {
      openArray("extension");
      for (Extension e : element.getExtension())
        composeExtension(null, e);
      closeArray();
    }
  }

  protected void composeBackbone(BackboneElement element) throws IOException {
    composeElement(element);
    if (element.hasModifierExtension()) {
      openArray("modifierExtension");
      for (Extension e : element.getModifierExtension())
        composeExtension(null, e);
      closeArray();
    }
  }

  protected <E extends Enum<E>> void composeEnumerationCore(String name, Enumeration<E> value, EnumFactory e,
      boolean inArray) throws IOException {
    if (value != null && value.getValue() != null) {
      prop(name, e.toCode(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected <E extends Enum<E>> void composeEnumerationExtras(String name, Enumeration<E> value, EnumFactory e,
      boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDateCore(String name, DateType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.asStringValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDateExtras(String name, DateType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDateTimeCore(String name, DateTimeType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.asStringValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDateTimeExtras(String name, DateTimeType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeCodeCore(String name, CodeType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeCodeExtras(String name, CodeType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeStringCore(String name, StringType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeStringExtras(String name, StringType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeIntegerCore(String name, IntegerType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, Integer.valueOf(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeIntegerExtras(String name, IntegerType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeOidCore(String name, OidType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeOidExtras(String name, OidType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUriCore(String name, UriType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUriExtras(String name, UriType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUuidCore(String name, UuidType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUuidExtras(String name, UuidType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeInstantCore(String name, InstantType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.asStringValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeInstantExtras(String name, InstantType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeBooleanCore(String name, BooleanType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.getValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeBooleanExtras(String name, BooleanType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeBase64BinaryCore(String name, Base64BinaryType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeBase64BinaryExtras(String name, Base64BinaryType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUnsignedIntCore(String name, UnsignedIntType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, Integer.valueOf(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeUnsignedIntExtras(String name, UnsignedIntType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeMarkdownCore(String name, MarkdownType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeMarkdownExtras(String name, MarkdownType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeTimeCore(String name, TimeType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.asStringValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeTimeExtras(String name, TimeType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeIdCore(String name, IdType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, toString(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composeIdExtras(String name, IdType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composePositiveIntCore(String name, PositiveIntType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, Integer.valueOf(value.getValue()));
    } else if (inArray)
      writeNull(name);
  }

  protected void composePositiveIntExtras(String name, PositiveIntType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDecimalCore(String name, DecimalType value, boolean inArray) throws IOException {
    if (value != null && value.hasValue()) {
      prop(name, value.getValue());
    } else if (inArray)
      writeNull(name);
  }

  protected void composeDecimalExtras(String name, DecimalType value, boolean inArray) throws IOException {
    if (value != null
        && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || makeComments(value))) {
      open(inArray ? null : "_" + name);
      composeElement(value);
      close();
    } else if (inArray)
      writeNull(name);
  }

  protected void composeExtension(String name, Extension element) throws IOException {
    if (element != null) {
      open(name);
      composeExtensionInner(element);
      close();
    }
  }

  protected void composeExtensionInner(Extension element) throws IOException {
    composeElement(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
  }

  protected void composeNarrative(String name, Narrative element) throws IOException {
    if (element != null) {
      open(name);
      composeNarrativeInner(element);
      close();
    }
  }

  protected void composeNarrativeInner(Narrative element) throws IOException {
    composeElement(element);
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Narrative.NarrativeStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Narrative.NarrativeStatusEnumFactory(), false);
    }
    if (element.hasDiv()) {
      composeXhtml("div", element.getDiv());
    }
  }

  protected void composeIdentifier(String name, Identifier element) throws IOException {
    if (element != null) {
      open(name);
      composeIdentifierInner(element);
      close();
    }
  }

  protected void composeIdentifierInner(Identifier element) throws IOException {
    composeElement(element);
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new Identifier.IdentifierUseEnumFactory(), false);
      composeEnumerationExtras("use", element.getUseElement(), new Identifier.IdentifierUseEnumFactory(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasAssigner()) {
      composeReference("assigner", element.getAssigner());
    }
  }

  protected void composeCoding(String name, Coding element) throws IOException {
    if (element != null) {
      open(name);
      composeCodingInner(element);
      close();
    }
  }

  protected void composeCodingInner(Coding element) throws IOException {
    composeElement(element);
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasUserSelectedElement()) {
      composeBooleanCore("userSelected", element.getUserSelectedElement(), false);
      composeBooleanExtras("userSelected", element.getUserSelectedElement(), false);
    }
  }

  protected void composeReference(String name, Reference element) throws IOException {
    if (element != null) {
      open(name);
      composeReferenceInner(element);
      close();
    }
  }

  protected void composeReferenceInner(Reference element) throws IOException {
    composeElement(element);
    if (element.hasReferenceElement()) {
      composeStringCore("reference", element.getReferenceElement(), false);
      composeStringExtras("reference", element.getReferenceElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
  }

  protected void composeSignature(String name, Signature element) throws IOException {
    if (element != null) {
      open(name);
      composeSignatureInner(element);
      close();
    }
  }

  protected void composeSignatureInner(Signature element) throws IOException {
    composeElement(element);
    if (element.hasType()) {
      openArray("type");
      for (Coding e : element.getType())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasWhenElement()) {
      composeInstantCore("when", element.getWhenElement(), false);
      composeInstantExtras("when", element.getWhenElement(), false);
    }
    if (element.hasWho()) {
      composeType("who", element.getWho());
    }
    if (element.hasContentTypeElement()) {
      composeCodeCore("contentType", element.getContentTypeElement(), false);
      composeCodeExtras("contentType", element.getContentTypeElement(), false);
    }
    if (element.hasBlobElement()) {
      composeBase64BinaryCore("blob", element.getBlobElement(), false);
      composeBase64BinaryExtras("blob", element.getBlobElement(), false);
    }
  }

  protected void composeSampledData(String name, SampledData element) throws IOException {
    if (element != null) {
      open(name);
      composeSampledDataInner(element);
      close();
    }
  }

  protected void composeSampledDataInner(SampledData element) throws IOException {
    composeElement(element);
    if (element.hasOrigin()) {
      composeSimpleQuantity("origin", element.getOrigin());
    }
    if (element.hasPeriodElement()) {
      composeDecimalCore("period", element.getPeriodElement(), false);
      composeDecimalExtras("period", element.getPeriodElement(), false);
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasLowerLimitElement()) {
      composeDecimalCore("lowerLimit", element.getLowerLimitElement(), false);
      composeDecimalExtras("lowerLimit", element.getLowerLimitElement(), false);
    }
    if (element.hasUpperLimitElement()) {
      composeDecimalCore("upperLimit", element.getUpperLimitElement(), false);
      composeDecimalExtras("upperLimit", element.getUpperLimitElement(), false);
    }
    if (element.hasDimensionsElement()) {
      composePositiveIntCore("dimensions", element.getDimensionsElement(), false);
      composePositiveIntExtras("dimensions", element.getDimensionsElement(), false);
    }
    if (element.hasDataElement()) {
      composeStringCore("data", element.getDataElement(), false);
      composeStringExtras("data", element.getDataElement(), false);
    }
  }

  protected void composeQuantity(String name, Quantity element) throws IOException {
    if (element != null) {
      open(name);
      composeQuantityInner(element);
      close();
    }
  }

  protected void composeQuantityInner(Quantity element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Quantity.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(),
          new Quantity.QuantityComparatorEnumFactory(), false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composePeriod(String name, Period element) throws IOException {
    if (element != null) {
      open(name);
      composePeriodInner(element);
      close();
    }
  }

  protected void composePeriodInner(Period element) throws IOException {
    composeElement(element);
    if (element.hasStartElement()) {
      composeDateTimeCore("start", element.getStartElement(), false);
      composeDateTimeExtras("start", element.getStartElement(), false);
    }
    if (element.hasEndElement()) {
      composeDateTimeCore("end", element.getEndElement(), false);
      composeDateTimeExtras("end", element.getEndElement(), false);
    }
  }

  protected void composeAttachment(String name, Attachment element) throws IOException {
    if (element != null) {
      open(name);
      composeAttachmentInner(element);
      close();
    }
  }

  protected void composeAttachmentInner(Attachment element) throws IOException {
    composeElement(element);
    if (element.hasContentTypeElement()) {
      composeCodeCore("contentType", element.getContentTypeElement(), false);
      composeCodeExtras("contentType", element.getContentTypeElement(), false);
    }
    if (element.hasLanguageElement()) {
      composeCodeCore("language", element.getLanguageElement(), false);
      composeCodeExtras("language", element.getLanguageElement(), false);
    }
    if (element.hasDataElement()) {
      composeBase64BinaryCore("data", element.getDataElement(), false);
      composeBase64BinaryExtras("data", element.getDataElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasSizeElement()) {
      composeUnsignedIntCore("size", element.getSizeElement(), false);
      composeUnsignedIntExtras("size", element.getSizeElement(), false);
    }
    if (element.hasHashElement()) {
      composeBase64BinaryCore("hash", element.getHashElement(), false);
      composeBase64BinaryExtras("hash", element.getHashElement(), false);
    }
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasCreationElement()) {
      composeDateTimeCore("creation", element.getCreationElement(), false);
      composeDateTimeExtras("creation", element.getCreationElement(), false);
    }
  }

  protected void composeRatio(String name, Ratio element) throws IOException {
    if (element != null) {
      open(name);
      composeRatioInner(element);
      close();
    }
  }

  protected void composeRatioInner(Ratio element) throws IOException {
    composeElement(element);
    if (element.hasNumerator()) {
      composeQuantity("numerator", element.getNumerator());
    }
    if (element.hasDenominator()) {
      composeQuantity("denominator", element.getDenominator());
    }
  }

  protected void composeRange(String name, Range element) throws IOException {
    if (element != null) {
      open(name);
      composeRangeInner(element);
      close();
    }
  }

  protected void composeRangeInner(Range element) throws IOException {
    composeElement(element);
    if (element.hasLow()) {
      composeSimpleQuantity("low", element.getLow());
    }
    if (element.hasHigh()) {
      composeSimpleQuantity("high", element.getHigh());
    }
  }

  protected void composeAnnotation(String name, Annotation element) throws IOException {
    if (element != null) {
      open(name);
      composeAnnotationInner(element);
      close();
    }
  }

  protected void composeAnnotationInner(Annotation element) throws IOException {
    composeElement(element);
    if (element.hasAuthor()) {
      composeType("author", element.getAuthor());
    }
    if (element.hasTimeElement()) {
      composeDateTimeCore("time", element.getTimeElement(), false);
      composeDateTimeExtras("time", element.getTimeElement(), false);
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composeCodeableConcept(String name, CodeableConcept element) throws IOException {
    if (element != null) {
      open(name);
      composeCodeableConceptInner(element);
      close();
    }
  }

  protected void composeCodeableConceptInner(CodeableConcept element) throws IOException {
    composeElement(element);
    if (element.hasCoding()) {
      openArray("coding");
      for (Coding e : element.getCoding())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composeMoney(String name, Money element) throws IOException {
    if (element != null) {
      open(name);
      composeMoneyInner(element);
      close();
    }
  }

  protected void composeMoneyInner(Money element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Money.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(), new Money.QuantityComparatorEnumFactory(),
          false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeSimpleQuantity(String name, SimpleQuantity element) throws IOException {
    if (element != null) {
      open(name);
      composeSimpleQuantityInner(element);
      close();
    }
  }

  protected void composeSimpleQuantityInner(SimpleQuantity element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(),
          new SimpleQuantity.QuantityComparatorEnumFactory(), false);
      composeEnumerationExtras("comparator", element.getComparatorElement(),
          new SimpleQuantity.QuantityComparatorEnumFactory(), false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeDuration(String name, Duration element) throws IOException {
    if (element != null) {
      open(name);
      composeDurationInner(element);
      close();
    }
  }

  protected void composeDurationInner(Duration element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Duration.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(),
          new Duration.QuantityComparatorEnumFactory(), false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeCount(String name, Count element) throws IOException {
    if (element != null) {
      open(name);
      composeCountInner(element);
      close();
    }
  }

  protected void composeCountInner(Count element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Count.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(), new Count.QuantityComparatorEnumFactory(),
          false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeDistance(String name, Distance element) throws IOException {
    if (element != null) {
      open(name);
      composeDistanceInner(element);
      close();
    }
  }

  protected void composeDistanceInner(Distance element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Distance.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(),
          new Distance.QuantityComparatorEnumFactory(), false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeAge(String name, Age element) throws IOException {
    if (element != null) {
      open(name);
      composeAgeInner(element);
      close();
    }
  }

  protected void composeAgeInner(Age element) throws IOException {
    composeElement(element);
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
    if (element.hasComparatorElement()) {
      composeEnumerationCore("comparator", element.getComparatorElement(), new Age.QuantityComparatorEnumFactory(),
          false);
      composeEnumerationExtras("comparator", element.getComparatorElement(), new Age.QuantityComparatorEnumFactory(),
          false);
    }
    if (element.hasUnitElement()) {
      composeStringCore("unit", element.getUnitElement(), false);
      composeStringExtras("unit", element.getUnitElement(), false);
    }
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeHumanName(String name, HumanName element) throws IOException {
    if (element != null) {
      open(name);
      composeHumanNameInner(element);
      close();
    }
  }

  protected void composeHumanNameInner(HumanName element) throws IOException {
    composeElement(element);
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new HumanName.NameUseEnumFactory(), false);
      composeEnumerationExtras("use", element.getUseElement(), new HumanName.NameUseEnumFactory(), false);
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasFamily()) {
      openArray("family");
      for (StringType e : element.getFamily())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getFamily())) {
        openArray("_family");
        for (StringType e : element.getFamily())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasGiven()) {
      openArray("given");
      for (StringType e : element.getGiven())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getGiven())) {
        openArray("_given");
        for (StringType e : element.getGiven())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPrefix()) {
      openArray("prefix");
      for (StringType e : element.getPrefix())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPrefix())) {
        openArray("_prefix");
        for (StringType e : element.getPrefix())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasSuffix()) {
      openArray("suffix");
      for (StringType e : element.getSuffix())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getSuffix())) {
        openArray("_suffix");
        for (StringType e : element.getSuffix())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeContactPoint(String name, ContactPoint element) throws IOException {
    if (element != null) {
      open(name);
      composeContactPointInner(element);
      close();
    }
  }

  protected void composeContactPointInner(ContactPoint element) throws IOException {
    composeElement(element);
    if (element.hasSystemElement()) {
      composeEnumerationCore("system", element.getSystemElement(), new ContactPoint.ContactPointSystemEnumFactory(),
          false);
      composeEnumerationExtras("system", element.getSystemElement(), new ContactPoint.ContactPointSystemEnumFactory(),
          false);
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new ContactPoint.ContactPointUseEnumFactory(), false);
      composeEnumerationExtras("use", element.getUseElement(), new ContactPoint.ContactPointUseEnumFactory(), false);
    }
    if (element.hasRankElement()) {
      composePositiveIntCore("rank", element.getRankElement(), false);
      composePositiveIntExtras("rank", element.getRankElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeMeta(String name, Meta element) throws IOException {
    if (element != null) {
      open(name);
      composeMetaInner(element);
      close();
    }
  }

  protected void composeMetaInner(Meta element) throws IOException {
    composeElement(element);
    if (element.hasVersionIdElement()) {
      composeIdCore("versionId", element.getVersionIdElement(), false);
      composeIdExtras("versionId", element.getVersionIdElement(), false);
    }
    if (element.hasLastUpdatedElement()) {
      composeInstantCore("lastUpdated", element.getLastUpdatedElement(), false);
      composeInstantExtras("lastUpdated", element.getLastUpdatedElement(), false);
    }
    if (element.hasProfile()) {
      openArray("profile");
      for (UriType e : element.getProfile())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getProfile())) {
        openArray("_profile");
        for (UriType e : element.getProfile())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasSecurity()) {
      openArray("security");
      for (Coding e : element.getSecurity())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasTag()) {
      openArray("tag");
      for (Coding e : element.getTag())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAddress(String name, Address element) throws IOException {
    if (element != null) {
      open(name);
      composeAddressInner(element);
      close();
    }
  }

  protected void composeAddressInner(Address element) throws IOException {
    composeElement(element);
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new Address.AddressUseEnumFactory(), false);
      composeEnumerationExtras("use", element.getUseElement(), new Address.AddressUseEnumFactory(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Address.AddressTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Address.AddressTypeEnumFactory(), false);
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasLine()) {
      openArray("line");
      for (StringType e : element.getLine())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getLine())) {
        openArray("_line");
        for (StringType e : element.getLine())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasCityElement()) {
      composeStringCore("city", element.getCityElement(), false);
      composeStringExtras("city", element.getCityElement(), false);
    }
    if (element.hasDistrictElement()) {
      composeStringCore("district", element.getDistrictElement(), false);
      composeStringExtras("district", element.getDistrictElement(), false);
    }
    if (element.hasStateElement()) {
      composeStringCore("state", element.getStateElement(), false);
      composeStringExtras("state", element.getStateElement(), false);
    }
    if (element.hasPostalCodeElement()) {
      composeStringCore("postalCode", element.getPostalCodeElement(), false);
      composeStringExtras("postalCode", element.getPostalCodeElement(), false);
    }
    if (element.hasCountryElement()) {
      composeStringCore("country", element.getCountryElement(), false);
      composeStringExtras("country", element.getCountryElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeTiming(String name, Timing element) throws IOException {
    if (element != null) {
      open(name);
      composeTimingInner(element);
      close();
    }
  }

  protected void composeTimingInner(Timing element) throws IOException {
    composeElement(element);
    if (element.hasEvent()) {
      openArray("event");
      for (DateTimeType e : element.getEvent())
        composeDateTimeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getEvent())) {
        openArray("_event");
        for (DateTimeType e : element.getEvent())
          composeDateTimeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasRepeat()) {
      composeTimingTimingRepeatComponent("repeat", element.getRepeat());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
  }

  protected void composeTimingTimingRepeatComponent(String name, Timing.TimingRepeatComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeTimingTimingRepeatComponentInner(element);
      close();
    }
  }

  protected void composeTimingTimingRepeatComponentInner(Timing.TimingRepeatComponent element) throws IOException {
    composeElement(element);
    if (element.hasBounds()) {
      composeType("bounds", element.getBounds());
    }
    if (element.hasCountElement()) {
      composeIntegerCore("count", element.getCountElement(), false);
      composeIntegerExtras("count", element.getCountElement(), false);
    }
    if (element.hasDurationElement()) {
      composeDecimalCore("duration", element.getDurationElement(), false);
      composeDecimalExtras("duration", element.getDurationElement(), false);
    }
    if (element.hasDurationMaxElement()) {
      composeDecimalCore("durationMax", element.getDurationMaxElement(), false);
      composeDecimalExtras("durationMax", element.getDurationMaxElement(), false);
    }
    if (element.hasDurationUnitsElement()) {
      composeEnumerationCore("durationUnits", element.getDurationUnitsElement(), new Timing.UnitsOfTimeEnumFactory(),
          false);
      composeEnumerationExtras("durationUnits", element.getDurationUnitsElement(), new Timing.UnitsOfTimeEnumFactory(),
          false);
    }
    if (element.hasFrequencyElement()) {
      composeIntegerCore("frequency", element.getFrequencyElement(), false);
      composeIntegerExtras("frequency", element.getFrequencyElement(), false);
    }
    if (element.hasFrequencyMaxElement()) {
      composeIntegerCore("frequencyMax", element.getFrequencyMaxElement(), false);
      composeIntegerExtras("frequencyMax", element.getFrequencyMaxElement(), false);
    }
    if (element.hasPeriodElement()) {
      composeDecimalCore("period", element.getPeriodElement(), false);
      composeDecimalExtras("period", element.getPeriodElement(), false);
    }
    if (element.hasPeriodMaxElement()) {
      composeDecimalCore("periodMax", element.getPeriodMaxElement(), false);
      composeDecimalExtras("periodMax", element.getPeriodMaxElement(), false);
    }
    if (element.hasPeriodUnitsElement()) {
      composeEnumerationCore("periodUnits", element.getPeriodUnitsElement(), new Timing.UnitsOfTimeEnumFactory(),
          false);
      composeEnumerationExtras("periodUnits", element.getPeriodUnitsElement(), new Timing.UnitsOfTimeEnumFactory(),
          false);
    }
    if (element.hasWhenElement()) {
      composeEnumerationCore("when", element.getWhenElement(), new Timing.EventTimingEnumFactory(), false);
      composeEnumerationExtras("when", element.getWhenElement(), new Timing.EventTimingEnumFactory(), false);
    }
  }

  protected void composeElementDefinition(String name, ElementDefinition element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionInner(element);
      close();
    }
  }

  protected void composeElementDefinitionInner(ElementDefinition element) throws IOException {
    composeElement(element);
    if (element.hasPathElement()) {
      composeStringCore("path", element.getPathElement(), false);
      composeStringExtras("path", element.getPathElement(), false);
    }
    if (element.hasRepresentation()) {
      openArray("representation");
      for (Enumeration<ElementDefinition.PropertyRepresentation> e : element.getRepresentation())
        composeEnumerationCore(null, e, new ElementDefinition.PropertyRepresentationEnumFactory(), true);
      closeArray();
      if (anyHasExtras(element.getRepresentation())) {
        openArray("_representation");
        for (Enumeration<ElementDefinition.PropertyRepresentation> e : element.getRepresentation())
          composeEnumerationExtras(null, e, new ElementDefinition.PropertyRepresentationEnumFactory(), true);
        closeArray();
      }
    }
    ;
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasLabelElement()) {
      composeStringCore("label", element.getLabelElement(), false);
      composeStringExtras("label", element.getLabelElement(), false);
    }
    if (element.hasCode()) {
      openArray("code");
      for (Coding e : element.getCode())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasSlicing()) {
      composeElementDefinitionElementDefinitionSlicingComponent("slicing", element.getSlicing());
    }
    if (element.hasShortElement()) {
      composeStringCore("short", element.getShortElement(), false);
      composeStringExtras("short", element.getShortElement(), false);
    }
    if (element.hasDefinitionElement()) {
      composeMarkdownCore("definition", element.getDefinitionElement(), false);
      composeMarkdownExtras("definition", element.getDefinitionElement(), false);
    }
    if (element.hasCommentsElement()) {
      composeMarkdownCore("comments", element.getCommentsElement(), false);
      composeMarkdownExtras("comments", element.getCommentsElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeMarkdownCore("requirements", element.getRequirementsElement(), false);
      composeMarkdownExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasAlias()) {
      openArray("alias");
      for (StringType e : element.getAlias())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getAlias())) {
        openArray("_alias");
        for (StringType e : element.getAlias())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasMinElement()) {
      composeIntegerCore("min", element.getMinElement(), false);
      composeIntegerExtras("min", element.getMinElement(), false);
    }
    if (element.hasMaxElement()) {
      composeStringCore("max", element.getMaxElement(), false);
      composeStringExtras("max", element.getMaxElement(), false);
    }
    if (element.hasBase()) {
      composeElementDefinitionElementDefinitionBaseComponent("base", element.getBase());
    }
    if (element.hasType()) {
      openArray("type");
      for (ElementDefinition.TypeRefComponent e : element.getType())
        composeElementDefinitionTypeRefComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasNameReferenceElement()) {
      composeStringCore("nameReference", element.getNameReferenceElement(), false);
      composeStringExtras("nameReference", element.getNameReferenceElement(), false);
    }
    if (element.hasDefaultValue()) {
      composeType("defaultValue", element.getDefaultValue());
    }
    if (element.hasMeaningWhenMissingElement()) {
      composeMarkdownCore("meaningWhenMissing", element.getMeaningWhenMissingElement(), false);
      composeMarkdownExtras("meaningWhenMissing", element.getMeaningWhenMissingElement(), false);
    }
    if (element.hasFixed()) {
      composeType("fixed", element.getFixed());
    }
    if (element.hasPattern()) {
      composeType("pattern", element.getPattern());
    }
    if (element.hasExample()) {
      composeType("example", element.getExample());
    }
    if (element.hasMinValue()) {
      composeType("minValue", element.getMinValue());
    }
    if (element.hasMaxValue()) {
      composeType("maxValue", element.getMaxValue());
    }
    if (element.hasMaxLengthElement()) {
      composeIntegerCore("maxLength", element.getMaxLengthElement(), false);
      composeIntegerExtras("maxLength", element.getMaxLengthElement(), false);
    }
    if (element.hasCondition()) {
      openArray("condition");
      for (IdType e : element.getCondition())
        composeIdCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getCondition())) {
        openArray("_condition");
        for (IdType e : element.getCondition())
          composeIdExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasConstraint()) {
      openArray("constraint");
      for (ElementDefinition.ElementDefinitionConstraintComponent e : element.getConstraint())
        composeElementDefinitionElementDefinitionConstraintComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMustSupportElement()) {
      composeBooleanCore("mustSupport", element.getMustSupportElement(), false);
      composeBooleanExtras("mustSupport", element.getMustSupportElement(), false);
    }
    if (element.hasIsModifierElement()) {
      composeBooleanCore("isModifier", element.getIsModifierElement(), false);
      composeBooleanExtras("isModifier", element.getIsModifierElement(), false);
    }
    if (element.hasIsSummaryElement()) {
      composeBooleanCore("isSummary", element.getIsSummaryElement(), false);
      composeBooleanExtras("isSummary", element.getIsSummaryElement(), false);
    }
    if (element.hasBinding()) {
      composeElementDefinitionElementDefinitionBindingComponent("binding", element.getBinding());
    }
    if (element.hasMapping()) {
      openArray("mapping");
      for (ElementDefinition.ElementDefinitionMappingComponent e : element.getMapping())
        composeElementDefinitionElementDefinitionMappingComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeElementDefinitionElementDefinitionSlicingComponent(String name,
      ElementDefinition.ElementDefinitionSlicingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionElementDefinitionSlicingComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionElementDefinitionSlicingComponentInner(
      ElementDefinition.ElementDefinitionSlicingComponent element) throws IOException {
    composeElement(element);
    if (element.hasDiscriminator()) {
      openArray("discriminator");
      for (StringType e : element.getDiscriminator())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getDiscriminator())) {
        openArray("_discriminator");
        for (StringType e : element.getDiscriminator())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasOrderedElement()) {
      composeBooleanCore("ordered", element.getOrderedElement(), false);
      composeBooleanExtras("ordered", element.getOrderedElement(), false);
    }
    if (element.hasRulesElement()) {
      composeEnumerationCore("rules", element.getRulesElement(), new ElementDefinition.SlicingRulesEnumFactory(),
          false);
      composeEnumerationExtras("rules", element.getRulesElement(), new ElementDefinition.SlicingRulesEnumFactory(),
          false);
    }
  }

  protected void composeElementDefinitionElementDefinitionBaseComponent(String name,
      ElementDefinition.ElementDefinitionBaseComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionElementDefinitionBaseComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionElementDefinitionBaseComponentInner(
      ElementDefinition.ElementDefinitionBaseComponent element) throws IOException {
    composeElement(element);
    if (element.hasPathElement()) {
      composeStringCore("path", element.getPathElement(), false);
      composeStringExtras("path", element.getPathElement(), false);
    }
    if (element.hasMinElement()) {
      composeIntegerCore("min", element.getMinElement(), false);
      composeIntegerExtras("min", element.getMinElement(), false);
    }
    if (element.hasMaxElement()) {
      composeStringCore("max", element.getMaxElement(), false);
      composeStringExtras("max", element.getMaxElement(), false);
    }
  }

  protected void composeElementDefinitionTypeRefComponent(String name, ElementDefinition.TypeRefComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionTypeRefComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionTypeRefComponentInner(ElementDefinition.TypeRefComponent element)
      throws IOException {
    composeElement(element);
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasProfile()) {
      openArray("profile");
      for (UriType e : element.getProfile())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getProfile())) {
        openArray("_profile");
        for (UriType e : element.getProfile())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasAggregation()) {
      openArray("aggregation");
      for (Enumeration<ElementDefinition.AggregationMode> e : element.getAggregation())
        composeEnumerationCore(null, e, new ElementDefinition.AggregationModeEnumFactory(), true);
      closeArray();
      if (anyHasExtras(element.getAggregation())) {
        openArray("_aggregation");
        for (Enumeration<ElementDefinition.AggregationMode> e : element.getAggregation())
          composeEnumerationExtras(null, e, new ElementDefinition.AggregationModeEnumFactory(), true);
        closeArray();
      }
    }
    ;
  }

  protected void composeElementDefinitionElementDefinitionConstraintComponent(String name,
      ElementDefinition.ElementDefinitionConstraintComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionElementDefinitionConstraintComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionElementDefinitionConstraintComponentInner(
      ElementDefinition.ElementDefinitionConstraintComponent element) throws IOException {
    composeElement(element);
    if (element.hasKeyElement()) {
      composeIdCore("key", element.getKeyElement(), false);
      composeIdExtras("key", element.getKeyElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasSeverityElement()) {
      composeEnumerationCore("severity", element.getSeverityElement(),
          new ElementDefinition.ConstraintSeverityEnumFactory(), false);
      composeEnumerationExtras("severity", element.getSeverityElement(),
          new ElementDefinition.ConstraintSeverityEnumFactory(), false);
    }
    if (element.hasHumanElement()) {
      composeStringCore("human", element.getHumanElement(), false);
      composeStringExtras("human", element.getHumanElement(), false);
    }
    if (element.hasXpathElement()) {
      composeStringCore("xpath", element.getXpathElement(), false);
      composeStringExtras("xpath", element.getXpathElement(), false);
    }
  }

  protected void composeElementDefinitionElementDefinitionBindingComponent(String name,
      ElementDefinition.ElementDefinitionBindingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionElementDefinitionBindingComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionElementDefinitionBindingComponentInner(
      ElementDefinition.ElementDefinitionBindingComponent element) throws IOException {
    composeElement(element);
    if (element.hasStrengthElement()) {
      composeEnumerationCore("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory(),
          false);
      composeEnumerationExtras("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory(),
          false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasValueSet()) {
      composeType("valueSet", element.getValueSet());
    }
  }

  protected void composeElementDefinitionElementDefinitionMappingComponent(String name,
      ElementDefinition.ElementDefinitionMappingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeElementDefinitionElementDefinitionMappingComponentInner(element);
      close();
    }
  }

  protected void composeElementDefinitionElementDefinitionMappingComponentInner(
      ElementDefinition.ElementDefinitionMappingComponent element) throws IOException {
    composeElement(element);
    if (element.hasIdentityElement()) {
      composeIdCore("identity", element.getIdentityElement(), false);
      composeIdExtras("identity", element.getIdentityElement(), false);
    }
    if (element.hasLanguageElement()) {
      composeCodeCore("language", element.getLanguageElement(), false);
      composeCodeExtras("language", element.getLanguageElement(), false);
    }
    if (element.hasMapElement()) {
      composeStringCore("map", element.getMapElement(), false);
      composeStringExtras("map", element.getMapElement(), false);
    }
  }

  protected void composeDomainResourceElements(DomainResource element) throws IOException {
    composeResourceElements(element);
    if (element.hasText()) {
      composeNarrative("text", element.getText());
    }
    if (element.hasContained()) {
      openArray("contained");
      for (Resource e : element.getContained()) {
        open(null);
        composeResource(e);
        close();
      }
      closeArray();
    }
    ;
    if (element.hasExtension()) {
      openArray("extension");
      for (Extension e : element.getExtension())
        composeExtension(null, e);
      closeArray();
    }
    ;
    if (element.hasModifierExtension()) {
      openArray("modifierExtension");
      for (Extension e : element.getModifierExtension())
        composeExtension(null, e);
      closeArray();
    }
    ;
  }

  protected void composeParameters(String name, Parameters element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeParametersInner(element);
    }
  }

  protected void composeParametersInner(Parameters element) throws IOException {
    composeResourceElements(element);
    if (element.hasParameter()) {
      openArray("parameter");
      for (Parameters.ParametersParameterComponent e : element.getParameter())
        composeParametersParametersParameterComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeParametersParametersParameterComponent(String name,
      Parameters.ParametersParameterComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeParametersParametersParameterComponentInner(element);
      close();
    }
  }

  protected void composeParametersParametersParameterComponentInner(Parameters.ParametersParameterComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
    if (element.hasResource()) {
      open("resource");
      composeResource(element.getResource());
      close();
    }
    if (element.hasPart()) {
      openArray("part");
      for (Parameters.ParametersParameterComponent e : element.getPart())
        composeParametersParametersParameterComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeResourceElements(Resource element) throws IOException {
    if (element.hasIdElement()) {
      composeIdCore("id", element.getIdElement(), false);
      composeIdExtras("id", element.getIdElement(), false);
    }
    if (element.hasMeta()) {
      composeMeta("meta", element.getMeta());
    }
    if (element.hasImplicitRulesElement()) {
      composeUriCore("implicitRules", element.getImplicitRulesElement(), false);
      composeUriExtras("implicitRules", element.getImplicitRulesElement(), false);
    }
    if (element.hasLanguageElement()) {
      composeCodeCore("language", element.getLanguageElement(), false);
      composeCodeExtras("language", element.getLanguageElement(), false);
    }
  }

  protected void composeAccount(String name, Account element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeAccountInner(element);
    }
  }

  protected void composeAccountInner(Account element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Account.AccountStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Account.AccountStatusEnumFactory(), false);
    }
    if (element.hasActivePeriod()) {
      composePeriod("activePeriod", element.getActivePeriod());
    }
    if (element.hasCurrency()) {
      composeCoding("currency", element.getCurrency());
    }
    if (element.hasBalance()) {
      composeMoney("balance", element.getBalance());
    }
    if (element.hasCoveragePeriod()) {
      composePeriod("coveragePeriod", element.getCoveragePeriod());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasOwner()) {
      composeReference("owner", element.getOwner());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
  }

  protected void composeAllergyIntolerance(String name, AllergyIntolerance element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeAllergyIntoleranceInner(element);
    }
  }

  protected void composeAllergyIntoleranceInner(AllergyIntolerance element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasOnsetElement()) {
      composeDateTimeCore("onset", element.getOnsetElement(), false);
      composeDateTimeExtras("onset", element.getOnsetElement(), false);
    }
    if (element.hasRecordedDateElement()) {
      composeDateTimeCore("recordedDate", element.getRecordedDateElement(), false);
      composeDateTimeExtras("recordedDate", element.getRecordedDateElement(), false);
    }
    if (element.hasRecorder()) {
      composeReference("recorder", element.getRecorder());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasReporter()) {
      composeReference("reporter", element.getReporter());
    }
    if (element.hasSubstance()) {
      composeCodeableConcept("substance", element.getSubstance());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new AllergyIntolerance.AllergyIntoleranceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new AllergyIntolerance.AllergyIntoleranceStatusEnumFactory(), false);
    }
    if (element.hasCriticalityElement()) {
      composeEnumerationCore("criticality", element.getCriticalityElement(),
          new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory(), false);
      composeEnumerationExtras("criticality", element.getCriticalityElement(),
          new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(),
          new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory(), false);
    }
    if (element.hasCategoryElement()) {
      composeEnumerationCore("category", element.getCategoryElement(),
          new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory(), false);
      composeEnumerationExtras("category", element.getCategoryElement(),
          new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory(), false);
    }
    if (element.hasLastOccurenceElement()) {
      composeDateTimeCore("lastOccurence", element.getLastOccurenceElement(), false);
      composeDateTimeExtras("lastOccurence", element.getLastOccurenceElement(), false);
    }
    if (element.hasNote()) {
      composeAnnotation("note", element.getNote());
    }
    if (element.hasReaction()) {
      openArray("reaction");
      for (AllergyIntolerance.AllergyIntoleranceReactionComponent e : element.getReaction())
        composeAllergyIntoleranceAllergyIntoleranceReactionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(String name,
      AllergyIntolerance.AllergyIntoleranceReactionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeAllergyIntoleranceAllergyIntoleranceReactionComponentInner(element);
      close();
    }
  }

  protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponentInner(
      AllergyIntolerance.AllergyIntoleranceReactionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSubstance()) {
      composeCodeableConcept("substance", element.getSubstance());
    }
    if (element.hasCertaintyElement()) {
      composeEnumerationCore("certainty", element.getCertaintyElement(),
          new AllergyIntolerance.AllergyIntoleranceCertaintyEnumFactory(), false);
      composeEnumerationExtras("certainty", element.getCertaintyElement(),
          new AllergyIntolerance.AllergyIntoleranceCertaintyEnumFactory(), false);
    }
    if (element.hasManifestation()) {
      openArray("manifestation");
      for (CodeableConcept e : element.getManifestation())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasOnsetElement()) {
      composeDateTimeCore("onset", element.getOnsetElement(), false);
      composeDateTimeExtras("onset", element.getOnsetElement(), false);
    }
    if (element.hasSeverityElement()) {
      composeEnumerationCore("severity", element.getSeverityElement(),
          new AllergyIntolerance.AllergyIntoleranceSeverityEnumFactory(), false);
      composeEnumerationExtras("severity", element.getSeverityElement(),
          new AllergyIntolerance.AllergyIntoleranceSeverityEnumFactory(), false);
    }
    if (element.hasExposureRoute()) {
      composeCodeableConcept("exposureRoute", element.getExposureRoute());
    }
    if (element.hasNote()) {
      composeAnnotation("note", element.getNote());
    }
  }

  protected void composeAppointment(String name, Appointment element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeAppointmentInner(element);
    }
  }

  protected void composeAppointmentInner(Appointment element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Appointment.AppointmentStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Appointment.AppointmentStatusEnumFactory(),
          false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasReason()) {
      composeCodeableConcept("reason", element.getReason());
    }
    if (element.hasPriorityElement()) {
      composeUnsignedIntCore("priority", element.getPriorityElement(), false);
      composeUnsignedIntExtras("priority", element.getPriorityElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasStartElement()) {
      composeInstantCore("start", element.getStartElement(), false);
      composeInstantExtras("start", element.getStartElement(), false);
    }
    if (element.hasEndElement()) {
      composeInstantCore("end", element.getEndElement(), false);
      composeInstantExtras("end", element.getEndElement(), false);
    }
    if (element.hasMinutesDurationElement()) {
      composePositiveIntCore("minutesDuration", element.getMinutesDurationElement(), false);
      composePositiveIntExtras("minutesDuration", element.getMinutesDurationElement(), false);
    }
    if (element.hasSlot()) {
      openArray("slot");
      for (Reference e : element.getSlot())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
    if (element.hasParticipant()) {
      openArray("participant");
      for (Appointment.AppointmentParticipantComponent e : element.getParticipant())
        composeAppointmentAppointmentParticipantComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAppointmentAppointmentParticipantComponent(String name,
      Appointment.AppointmentParticipantComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeAppointmentAppointmentParticipantComponentInner(element);
      close();
    }
  }

  protected void composeAppointmentAppointmentParticipantComponentInner(
      Appointment.AppointmentParticipantComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
    if (element.hasRequiredElement()) {
      composeEnumerationCore("required", element.getRequiredElement(), new Appointment.ParticipantRequiredEnumFactory(),
          false);
      composeEnumerationExtras("required", element.getRequiredElement(),
          new Appointment.ParticipantRequiredEnumFactory(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Appointment.ParticipationStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Appointment.ParticipationStatusEnumFactory(),
          false);
    }
  }

  protected void composeAppointmentResponse(String name, AppointmentResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeAppointmentResponseInner(element);
    }
  }

  protected void composeAppointmentResponseInner(AppointmentResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasAppointment()) {
      composeReference("appointment", element.getAppointment());
    }
    if (element.hasStartElement()) {
      composeInstantCore("start", element.getStartElement(), false);
      composeInstantExtras("start", element.getStartElement(), false);
    }
    if (element.hasEndElement()) {
      composeInstantCore("end", element.getEndElement(), false);
      composeInstantExtras("end", element.getEndElement(), false);
    }
    if (element.hasParticipantType()) {
      openArray("participantType");
      for (CodeableConcept e : element.getParticipantType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
    if (element.hasParticipantStatusElement()) {
      composeEnumerationCore("participantStatus", element.getParticipantStatusElement(),
          new AppointmentResponse.ParticipantStatusEnumFactory(), false);
      composeEnumerationExtras("participantStatus", element.getParticipantStatusElement(),
          new AppointmentResponse.ParticipantStatusEnumFactory(), false);
    }
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
  }

  protected void composeAuditEvent(String name, AuditEvent element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeAuditEventInner(element);
    }
  }

  protected void composeAuditEventInner(AuditEvent element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasEvent()) {
      composeAuditEventAuditEventEventComponent("event", element.getEvent());
    }
    if (element.hasParticipant()) {
      openArray("participant");
      for (AuditEvent.AuditEventParticipantComponent e : element.getParticipant())
        composeAuditEventAuditEventParticipantComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSource()) {
      composeAuditEventAuditEventSourceComponent("source", element.getSource());
    }
    if (element.hasObject()) {
      openArray("object");
      for (AuditEvent.AuditEventObjectComponent e : element.getObject())
        composeAuditEventAuditEventObjectComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAuditEventAuditEventEventComponent(String name, AuditEvent.AuditEventEventComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventEventComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventEventComponentInner(AuditEvent.AuditEventEventComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasSubtype()) {
      openArray("subtype");
      for (Coding e : element.getSubtype())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasActionElement()) {
      composeEnumerationCore("action", element.getActionElement(), new AuditEvent.AuditEventActionEnumFactory(), false);
      composeEnumerationExtras("action", element.getActionElement(), new AuditEvent.AuditEventActionEnumFactory(),
          false);
    }
    if (element.hasDateTimeElement()) {
      composeInstantCore("dateTime", element.getDateTimeElement(), false);
      composeInstantExtras("dateTime", element.getDateTimeElement(), false);
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new AuditEvent.AuditEventOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new AuditEvent.AuditEventOutcomeEnumFactory(),
          false);
    }
    if (element.hasOutcomeDescElement()) {
      composeStringCore("outcomeDesc", element.getOutcomeDescElement(), false);
      composeStringExtras("outcomeDesc", element.getOutcomeDescElement(), false);
    }
    if (element.hasPurposeOfEvent()) {
      openArray("purposeOfEvent");
      for (Coding e : element.getPurposeOfEvent())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAuditEventAuditEventParticipantComponent(String name,
      AuditEvent.AuditEventParticipantComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventParticipantComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventParticipantComponentInner(AuditEvent.AuditEventParticipantComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasRole()) {
      openArray("role");
      for (CodeableConcept e : element.getRole())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReference()) {
      composeReference("reference", element.getReference());
    }
    if (element.hasUserId()) {
      composeIdentifier("userId", element.getUserId());
    }
    if (element.hasAltIdElement()) {
      composeStringCore("altId", element.getAltIdElement(), false);
      composeStringExtras("altId", element.getAltIdElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasRequestorElement()) {
      composeBooleanCore("requestor", element.getRequestorElement(), false);
      composeBooleanExtras("requestor", element.getRequestorElement(), false);
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasPolicy()) {
      openArray("policy");
      for (UriType e : element.getPolicy())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPolicy())) {
        openArray("_policy");
        for (UriType e : element.getPolicy())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasMedia()) {
      composeCoding("media", element.getMedia());
    }
    if (element.hasNetwork()) {
      composeAuditEventAuditEventParticipantNetworkComponent("network", element.getNetwork());
    }
    if (element.hasPurposeOfUse()) {
      openArray("purposeOfUse");
      for (Coding e : element.getPurposeOfUse())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAuditEventAuditEventParticipantNetworkComponent(String name,
      AuditEvent.AuditEventParticipantNetworkComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventParticipantNetworkComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventParticipantNetworkComponentInner(
      AuditEvent.AuditEventParticipantNetworkComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasAddressElement()) {
      composeStringCore("address", element.getAddressElement(), false);
      composeStringExtras("address", element.getAddressElement(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(),
          new AuditEvent.AuditEventParticipantNetworkTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new AuditEvent.AuditEventParticipantNetworkTypeEnumFactory(), false);
    }
  }

  protected void composeAuditEventAuditEventSourceComponent(String name, AuditEvent.AuditEventSourceComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventSourceComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventSourceComponentInner(AuditEvent.AuditEventSourceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSiteElement()) {
      composeStringCore("site", element.getSiteElement(), false);
      composeStringExtras("site", element.getSiteElement(), false);
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasType()) {
      openArray("type");
      for (Coding e : element.getType())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAuditEventAuditEventObjectComponent(String name, AuditEvent.AuditEventObjectComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventObjectComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventObjectComponentInner(AuditEvent.AuditEventObjectComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasReference()) {
      composeReference("reference", element.getReference());
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasRole()) {
      composeCoding("role", element.getRole());
    }
    if (element.hasLifecycle()) {
      composeCoding("lifecycle", element.getLifecycle());
    }
    if (element.hasSecurityLabel()) {
      openArray("securityLabel");
      for (Coding e : element.getSecurityLabel())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasQueryElement()) {
      composeBase64BinaryCore("query", element.getQueryElement(), false);
      composeBase64BinaryExtras("query", element.getQueryElement(), false);
    }
    if (element.hasDetail()) {
      openArray("detail");
      for (AuditEvent.AuditEventObjectDetailComponent e : element.getDetail())
        composeAuditEventAuditEventObjectDetailComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeAuditEventAuditEventObjectDetailComponent(String name,
      AuditEvent.AuditEventObjectDetailComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeAuditEventAuditEventObjectDetailComponentInner(element);
      close();
    }
  }

  protected void composeAuditEventAuditEventObjectDetailComponentInner(
      AuditEvent.AuditEventObjectDetailComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeStringCore("type", element.getTypeElement(), false);
      composeStringExtras("type", element.getTypeElement(), false);
    }
    if (element.hasValueElement()) {
      composeBase64BinaryCore("value", element.getValueElement(), false);
      composeBase64BinaryExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeBasic(String name, Basic element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeBasicInner(element);
    }
  }

  protected void composeBasicInner(Basic element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasCreatedElement()) {
      composeDateCore("created", element.getCreatedElement(), false);
      composeDateExtras("created", element.getCreatedElement(), false);
    }
  }

  protected void composeBinary(String name, Binary element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeBinaryInner(element);
    }
  }

  protected void composeBinaryInner(Binary element) throws IOException {
    composeResourceElements(element);
    if (element.hasContentTypeElement()) {
      composeCodeCore("contentType", element.getContentTypeElement(), false);
      composeCodeExtras("contentType", element.getContentTypeElement(), false);
    }
    if (element.hasContentElement()) {
      composeBase64BinaryCore("content", element.getContentElement(), false);
      composeBase64BinaryExtras("content", element.getContentElement(), false);
    }
  }

  protected void composeBodySite(String name, BodySite element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeBodySiteInner(element);
    }
  }

  protected void composeBodySiteInner(BodySite element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasModifier()) {
      openArray("modifier");
      for (CodeableConcept e : element.getModifier())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasImage()) {
      openArray("image");
      for (Attachment e : element.getImage())
        composeAttachment(null, e);
      closeArray();
    }
    ;
  }

  protected void composeBundle(String name, Bundle element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeBundleInner(element);
    }
  }

  protected void composeBundleInner(Bundle element) throws IOException {
    composeResourceElements(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Bundle.BundleTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Bundle.BundleTypeEnumFactory(), false);
    }
    if (element.hasTotalElement()) {
      composeUnsignedIntCore("total", element.getTotalElement(), false);
      composeUnsignedIntExtras("total", element.getTotalElement(), false);
    }
    if (element.hasLink()) {
      openArray("link");
      for (Bundle.BundleLinkComponent e : element.getLink())
        composeBundleBundleLinkComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEntry()) {
      openArray("entry");
      for (Bundle.BundleEntryComponent e : element.getEntry())
        composeBundleBundleEntryComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSignature()) {
      composeSignature("signature", element.getSignature());
    }
  }

  protected void composeBundleBundleLinkComponent(String name, Bundle.BundleLinkComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeBundleBundleLinkComponentInner(element);
      close();
    }
  }

  protected void composeBundleBundleLinkComponentInner(Bundle.BundleLinkComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasRelationElement()) {
      composeStringCore("relation", element.getRelationElement(), false);
      composeStringExtras("relation", element.getRelationElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
  }

  protected void composeBundleBundleEntryComponent(String name, Bundle.BundleEntryComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeBundleBundleEntryComponentInner(element);
      close();
    }
  }

  protected void composeBundleBundleEntryComponentInner(Bundle.BundleEntryComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLink()) {
      openArray("link");
      for (Bundle.BundleLinkComponent e : element.getLink())
        composeBundleBundleLinkComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasFullUrlElement()) {
      composeUriCore("fullUrl", element.getFullUrlElement(), false);
      composeUriExtras("fullUrl", element.getFullUrlElement(), false);
    }
    if (element.hasResource()) {
      open("resource");
      composeResource(element.getResource());
      close();
    }
    if (element.hasSearch()) {
      composeBundleBundleEntrySearchComponent("search", element.getSearch());
    }
    if (element.hasRequest()) {
      composeBundleBundleEntryRequestComponent("request", element.getRequest());
    }
    if (element.hasResponse()) {
      composeBundleBundleEntryResponseComponent("response", element.getResponse());
    }
  }

  protected void composeBundleBundleEntrySearchComponent(String name, Bundle.BundleEntrySearchComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeBundleBundleEntrySearchComponentInner(element);
      close();
    }
  }

  protected void composeBundleBundleEntrySearchComponentInner(Bundle.BundleEntrySearchComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new Bundle.SearchEntryModeEnumFactory(), false);
      composeEnumerationExtras("mode", element.getModeElement(), new Bundle.SearchEntryModeEnumFactory(), false);
    }
    if (element.hasScoreElement()) {
      composeDecimalCore("score", element.getScoreElement(), false);
      composeDecimalExtras("score", element.getScoreElement(), false);
    }
  }

  protected void composeBundleBundleEntryRequestComponent(String name, Bundle.BundleEntryRequestComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeBundleBundleEntryRequestComponentInner(element);
      close();
    }
  }

  protected void composeBundleBundleEntryRequestComponentInner(Bundle.BundleEntryRequestComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasMethodElement()) {
      composeEnumerationCore("method", element.getMethodElement(), new Bundle.HTTPVerbEnumFactory(), false);
      composeEnumerationExtras("method", element.getMethodElement(), new Bundle.HTTPVerbEnumFactory(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasIfNoneMatchElement()) {
      composeStringCore("ifNoneMatch", element.getIfNoneMatchElement(), false);
      composeStringExtras("ifNoneMatch", element.getIfNoneMatchElement(), false);
    }
    if (element.hasIfModifiedSinceElement()) {
      composeInstantCore("ifModifiedSince", element.getIfModifiedSinceElement(), false);
      composeInstantExtras("ifModifiedSince", element.getIfModifiedSinceElement(), false);
    }
    if (element.hasIfMatchElement()) {
      composeStringCore("ifMatch", element.getIfMatchElement(), false);
      composeStringExtras("ifMatch", element.getIfMatchElement(), false);
    }
    if (element.hasIfNoneExistElement()) {
      composeStringCore("ifNoneExist", element.getIfNoneExistElement(), false);
      composeStringExtras("ifNoneExist", element.getIfNoneExistElement(), false);
    }
  }

  protected void composeBundleBundleEntryResponseComponent(String name, Bundle.BundleEntryResponseComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeBundleBundleEntryResponseComponentInner(element);
      close();
    }
  }

  protected void composeBundleBundleEntryResponseComponentInner(Bundle.BundleEntryResponseComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasStatusElement()) {
      composeStringCore("status", element.getStatusElement(), false);
      composeStringExtras("status", element.getStatusElement(), false);
    }
    if (element.hasLocationElement()) {
      composeUriCore("location", element.getLocationElement(), false);
      composeUriExtras("location", element.getLocationElement(), false);
    }
    if (element.hasEtagElement()) {
      composeStringCore("etag", element.getEtagElement(), false);
      composeStringExtras("etag", element.getEtagElement(), false);
    }
    if (element.hasLastModifiedElement()) {
      composeInstantCore("lastModified", element.getLastModifiedElement(), false);
      composeInstantExtras("lastModified", element.getLastModifiedElement(), false);
    }
  }

  protected void composeCarePlan(String name, CarePlan element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeCarePlanInner(element);
    }
  }

  protected void composeCarePlanInner(CarePlan element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new CarePlan.CarePlanStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new CarePlan.CarePlanStatusEnumFactory(), false);
    }
    if (element.hasContext()) {
      composeReference("context", element.getContext());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasAuthor()) {
      openArray("author");
      for (Reference e : element.getAuthor())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasModifiedElement()) {
      composeDateTimeCore("modified", element.getModifiedElement(), false);
      composeDateTimeExtras("modified", element.getModifiedElement(), false);
    }
    if (element.hasCategory()) {
      openArray("category");
      for (CodeableConcept e : element.getCategory())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAddresses()) {
      openArray("addresses");
      for (Reference e : element.getAddresses())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasSupport()) {
      openArray("support");
      for (Reference e : element.getSupport())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasRelatedPlan()) {
      openArray("relatedPlan");
      for (CarePlan.CarePlanRelatedPlanComponent e : element.getRelatedPlan())
        composeCarePlanCarePlanRelatedPlanComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasParticipant()) {
      openArray("participant");
      for (CarePlan.CarePlanParticipantComponent e : element.getParticipant())
        composeCarePlanCarePlanParticipantComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasGoal()) {
      openArray("goal");
      for (Reference e : element.getGoal())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasActivity()) {
      openArray("activity");
      for (CarePlan.CarePlanActivityComponent e : element.getActivity())
        composeCarePlanCarePlanActivityComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasNote()) {
      composeAnnotation("note", element.getNote());
    }
  }

  protected void composeCarePlanCarePlanRelatedPlanComponent(String name, CarePlan.CarePlanRelatedPlanComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeCarePlanCarePlanRelatedPlanComponentInner(element);
      close();
    }
  }

  protected void composeCarePlanCarePlanRelatedPlanComponentInner(CarePlan.CarePlanRelatedPlanComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(), new CarePlan.CarePlanRelationshipEnumFactory(), false);
      composeEnumerationExtras("code", element.getCodeElement(), new CarePlan.CarePlanRelationshipEnumFactory(), false);
    }
    if (element.hasPlan()) {
      composeReference("plan", element.getPlan());
    }
  }

  protected void composeCarePlanCarePlanParticipantComponent(String name, CarePlan.CarePlanParticipantComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeCarePlanCarePlanParticipantComponentInner(element);
      close();
    }
  }

  protected void composeCarePlanCarePlanParticipantComponentInner(CarePlan.CarePlanParticipantComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasRole()) {
      composeCodeableConcept("role", element.getRole());
    }
    if (element.hasMember()) {
      composeReference("member", element.getMember());
    }
  }

  protected void composeCarePlanCarePlanActivityComponent(String name, CarePlan.CarePlanActivityComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeCarePlanCarePlanActivityComponentInner(element);
      close();
    }
  }

  protected void composeCarePlanCarePlanActivityComponentInner(CarePlan.CarePlanActivityComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasActionResulting()) {
      openArray("actionResulting");
      for (Reference e : element.getActionResulting())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasProgress()) {
      openArray("progress");
      for (Annotation e : element.getProgress())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasReference()) {
      composeReference("reference", element.getReference());
    }
    if (element.hasDetail()) {
      composeCarePlanCarePlanActivityDetailComponent("detail", element.getDetail());
    }
  }

  protected void composeCarePlanCarePlanActivityDetailComponent(String name,
      CarePlan.CarePlanActivityDetailComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeCarePlanCarePlanActivityDetailComponentInner(element);
      close();
    }
  }

  protected void composeCarePlanCarePlanActivityDetailComponentInner(CarePlan.CarePlanActivityDetailComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasReasonCode()) {
      openArray("reasonCode");
      for (CodeableConcept e : element.getReasonCode())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReasonReference()) {
      openArray("reasonReference");
      for (Reference e : element.getReasonReference())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasGoal()) {
      openArray("goal");
      for (Reference e : element.getGoal())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new CarePlan.CarePlanActivityStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new CarePlan.CarePlanActivityStatusEnumFactory(),
          false);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept("statusReason", element.getStatusReason());
    }
    if (element.hasProhibitedElement()) {
      composeBooleanCore("prohibited", element.getProhibitedElement(), false);
      composeBooleanExtras("prohibited", element.getProhibitedElement(), false);
    }
    if (element.hasScheduled()) {
      composeType("scheduled", element.getScheduled());
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasPerformer()) {
      openArray("performer");
      for (Reference e : element.getPerformer())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasProduct()) {
      composeType("product", element.getProduct());
    }
    if (element.hasDailyAmount()) {
      composeSimpleQuantity("dailyAmount", element.getDailyAmount());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
  }

  protected void composeClaim(String name, Claim element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeClaimInner(element);
    }
  }

  protected void composeClaimInner(Claim element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Claim.ClaimTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Claim.ClaimTypeEnumFactory(), false);
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new Claim.UseEnumFactory(), false);
      composeEnumerationExtras("use", element.getUseElement(), new Claim.UseEnumFactory(), false);
    }
    if (element.hasPriority()) {
      composeCoding("priority", element.getPriority());
    }
    if (element.hasFundsReserve()) {
      composeCoding("fundsReserve", element.getFundsReserve());
    }
    if (element.hasEnterer()) {
      composeReference("enterer", element.getEnterer());
    }
    if (element.hasFacility()) {
      composeReference("facility", element.getFacility());
    }
    if (element.hasPrescription()) {
      composeReference("prescription", element.getPrescription());
    }
    if (element.hasOriginalPrescription()) {
      composeReference("originalPrescription", element.getOriginalPrescription());
    }
    if (element.hasPayee()) {
      composeClaimPayeeComponent("payee", element.getPayee());
    }
    if (element.hasReferral()) {
      composeReference("referral", element.getReferral());
    }
    if (element.hasDiagnosis()) {
      openArray("diagnosis");
      for (Claim.DiagnosisComponent e : element.getDiagnosis())
        composeClaimDiagnosisComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCondition()) {
      openArray("condition");
      for (Coding e : element.getCondition())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasCoverage()) {
      openArray("coverage");
      for (Claim.CoverageComponent e : element.getCoverage())
        composeClaimCoverageComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasException()) {
      openArray("exception");
      for (Coding e : element.getException())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasSchoolElement()) {
      composeStringCore("school", element.getSchoolElement(), false);
      composeStringExtras("school", element.getSchoolElement(), false);
    }
    if (element.hasAccidentElement()) {
      composeDateCore("accident", element.getAccidentElement(), false);
      composeDateExtras("accident", element.getAccidentElement(), false);
    }
    if (element.hasAccidentType()) {
      composeCoding("accidentType", element.getAccidentType());
    }
    if (element.hasInterventionException()) {
      openArray("interventionException");
      for (Coding e : element.getInterventionException())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasItem()) {
      openArray("item");
      for (Claim.ItemsComponent e : element.getItem())
        composeClaimItemsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasAdditionalMaterials()) {
      openArray("additionalMaterials");
      for (Coding e : element.getAdditionalMaterials())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasMissingTeeth()) {
      openArray("missingTeeth");
      for (Claim.MissingTeethComponent e : element.getMissingTeeth())
        composeClaimMissingTeethComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimPayeeComponent(String name, Claim.PayeeComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimPayeeComponentInner(element);
      close();
    }
  }

  protected void composeClaimPayeeComponentInner(Claim.PayeeComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasPerson()) {
      composeReference("person", element.getPerson());
    }
  }

  protected void composeClaimDiagnosisComponent(String name, Claim.DiagnosisComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimDiagnosisComponentInner(element);
      close();
    }
  }

  protected void composeClaimDiagnosisComponentInner(Claim.DiagnosisComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasDiagnosis()) {
      composeCoding("diagnosis", element.getDiagnosis());
    }
  }

  protected void composeClaimCoverageComponent(String name, Claim.CoverageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimCoverageComponentInner(element);
      close();
    }
  }

  protected void composeClaimCoverageComponentInner(Claim.CoverageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasFocalElement()) {
      composeBooleanCore("focal", element.getFocalElement(), false);
      composeBooleanExtras("focal", element.getFocalElement(), false);
    }
    if (element.hasCoverage()) {
      composeReference("coverage", element.getCoverage());
    }
    if (element.hasBusinessArrangementElement()) {
      composeStringCore("businessArrangement", element.getBusinessArrangementElement(), false);
      composeStringExtras("businessArrangement", element.getBusinessArrangementElement(), false);
    }
    if (element.hasRelationship()) {
      composeCoding("relationship", element.getRelationship());
    }
    if (element.hasPreAuthRef()) {
      openArray("preAuthRef");
      for (StringType e : element.getPreAuthRef())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPreAuthRef())) {
        openArray("_preAuthRef");
        for (StringType e : element.getPreAuthRef())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasClaimResponse()) {
      composeReference("claimResponse", element.getClaimResponse());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
  }

  protected void composeClaimItemsComponent(String name, Claim.ItemsComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimItemsComponentInner(element);
      close();
    }
  }

  protected void composeClaimItemsComponentInner(Claim.ItemsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasDiagnosisLinkId()) {
      openArray("diagnosisLinkId");
      for (PositiveIntType e : element.getDiagnosisLinkId())
        composePositiveIntCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getDiagnosisLinkId())) {
        openArray("_diagnosisLinkId");
        for (PositiveIntType e : element.getDiagnosisLinkId())
          composePositiveIntExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasService()) {
      composeCoding("service", element.getService());
    }
    if (element.hasServiceDateElement()) {
      composeDateCore("serviceDate", element.getServiceDateElement(), false);
      composeDateExtras("serviceDate", element.getServiceDateElement(), false);
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasUnitPrice()) {
      composeMoney("unitPrice", element.getUnitPrice());
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasPointsElement()) {
      composeDecimalCore("points", element.getPointsElement(), false);
      composeDecimalExtras("points", element.getPointsElement(), false);
    }
    if (element.hasNet()) {
      composeMoney("net", element.getNet());
    }
    if (element.hasUdi()) {
      composeCoding("udi", element.getUdi());
    }
    if (element.hasBodySite()) {
      composeCoding("bodySite", element.getBodySite());
    }
    if (element.hasSubSite()) {
      openArray("subSite");
      for (Coding e : element.getSubSite())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasModifier()) {
      openArray("modifier");
      for (Coding e : element.getModifier())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasDetail()) {
      openArray("detail");
      for (Claim.DetailComponent e : element.getDetail())
        composeClaimDetailComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasProsthesis()) {
      composeClaimProsthesisComponent("prosthesis", element.getProsthesis());
    }
  }

  protected void composeClaimDetailComponent(String name, Claim.DetailComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimDetailComponentInner(element);
      close();
    }
  }

  protected void composeClaimDetailComponentInner(Claim.DetailComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasService()) {
      composeCoding("service", element.getService());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasUnitPrice()) {
      composeMoney("unitPrice", element.getUnitPrice());
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasPointsElement()) {
      composeDecimalCore("points", element.getPointsElement(), false);
      composeDecimalExtras("points", element.getPointsElement(), false);
    }
    if (element.hasNet()) {
      composeMoney("net", element.getNet());
    }
    if (element.hasUdi()) {
      composeCoding("udi", element.getUdi());
    }
    if (element.hasSubDetail()) {
      openArray("subDetail");
      for (Claim.SubDetailComponent e : element.getSubDetail())
        composeClaimSubDetailComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimSubDetailComponent(String name, Claim.SubDetailComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimSubDetailComponentInner(element);
      close();
    }
  }

  protected void composeClaimSubDetailComponentInner(Claim.SubDetailComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasService()) {
      composeCoding("service", element.getService());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasUnitPrice()) {
      composeMoney("unitPrice", element.getUnitPrice());
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasPointsElement()) {
      composeDecimalCore("points", element.getPointsElement(), false);
      composeDecimalExtras("points", element.getPointsElement(), false);
    }
    if (element.hasNet()) {
      composeMoney("net", element.getNet());
    }
    if (element.hasUdi()) {
      composeCoding("udi", element.getUdi());
    }
  }

  protected void composeClaimProsthesisComponent(String name, Claim.ProsthesisComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimProsthesisComponentInner(element);
      close();
    }
  }

  protected void composeClaimProsthesisComponentInner(Claim.ProsthesisComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasInitialElement()) {
      composeBooleanCore("initial", element.getInitialElement(), false);
      composeBooleanExtras("initial", element.getInitialElement(), false);
    }
    if (element.hasPriorDateElement()) {
      composeDateCore("priorDate", element.getPriorDateElement(), false);
      composeDateExtras("priorDate", element.getPriorDateElement(), false);
    }
    if (element.hasPriorMaterial()) {
      composeCoding("priorMaterial", element.getPriorMaterial());
    }
  }

  protected void composeClaimMissingTeethComponent(String name, Claim.MissingTeethComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimMissingTeethComponentInner(element);
      close();
    }
  }

  protected void composeClaimMissingTeethComponentInner(Claim.MissingTeethComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTooth()) {
      composeCoding("tooth", element.getTooth());
    }
    if (element.hasReason()) {
      composeCoding("reason", element.getReason());
    }
    if (element.hasExtractionDateElement()) {
      composeDateCore("extractionDate", element.getExtractionDateElement(), false);
      composeDateExtras("extractionDate", element.getExtractionDateElement(), false);
    }
  }

  protected void composeClaimResponse(String name, ClaimResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeClaimResponseInner(element);
    }
  }

  protected void composeClaimResponseInner(ClaimResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasPayeeType()) {
      composeCoding("payeeType", element.getPayeeType());
    }
    if (element.hasItem()) {
      openArray("item");
      for (ClaimResponse.ItemsComponent e : element.getItem())
        composeClaimResponseItemsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasAddItem()) {
      openArray("addItem");
      for (ClaimResponse.AddedItemComponent e : element.getAddItem())
        composeClaimResponseAddedItemComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasError()) {
      openArray("error");
      for (ClaimResponse.ErrorsComponent e : element.getError())
        composeClaimResponseErrorsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTotalCost()) {
      composeMoney("totalCost", element.getTotalCost());
    }
    if (element.hasUnallocDeductable()) {
      composeMoney("unallocDeductable", element.getUnallocDeductable());
    }
    if (element.hasTotalBenefit()) {
      composeMoney("totalBenefit", element.getTotalBenefit());
    }
    if (element.hasPaymentAdjustment()) {
      composeMoney("paymentAdjustment", element.getPaymentAdjustment());
    }
    if (element.hasPaymentAdjustmentReason()) {
      composeCoding("paymentAdjustmentReason", element.getPaymentAdjustmentReason());
    }
    if (element.hasPaymentDateElement()) {
      composeDateCore("paymentDate", element.getPaymentDateElement(), false);
      composeDateExtras("paymentDate", element.getPaymentDateElement(), false);
    }
    if (element.hasPaymentAmount()) {
      composeMoney("paymentAmount", element.getPaymentAmount());
    }
    if (element.hasPaymentRef()) {
      composeIdentifier("paymentRef", element.getPaymentRef());
    }
    if (element.hasReserved()) {
      composeCoding("reserved", element.getReserved());
    }
    if (element.hasForm()) {
      composeCoding("form", element.getForm());
    }
    if (element.hasNote()) {
      openArray("note");
      for (ClaimResponse.NotesComponent e : element.getNote())
        composeClaimResponseNotesComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCoverage()) {
      openArray("coverage");
      for (ClaimResponse.CoverageComponent e : element.getCoverage())
        composeClaimResponseCoverageComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseItemsComponent(String name, ClaimResponse.ItemsComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseItemsComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseItemsComponentInner(ClaimResponse.ItemsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkIdElement()) {
      composePositiveIntCore("sequenceLinkId", element.getSequenceLinkIdElement(), false);
      composePositiveIntExtras("sequenceLinkId", element.getSequenceLinkIdElement(), false);
    }
    if (element.hasNoteNumber()) {
      openArray("noteNumber");
      for (PositiveIntType e : element.getNoteNumber())
        composePositiveIntCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getNoteNumber())) {
        openArray("_noteNumber");
        for (PositiveIntType e : element.getNoteNumber())
          composePositiveIntExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasAdjudication()) {
      openArray("adjudication");
      for (ClaimResponse.ItemAdjudicationComponent e : element.getAdjudication())
        composeClaimResponseItemAdjudicationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDetail()) {
      openArray("detail");
      for (ClaimResponse.ItemDetailComponent e : element.getDetail())
        composeClaimResponseItemDetailComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseItemAdjudicationComponent(String name,
      ClaimResponse.ItemAdjudicationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseItemAdjudicationComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseItemAdjudicationComponentInner(ClaimResponse.ItemAdjudicationComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeClaimResponseItemDetailComponent(String name, ClaimResponse.ItemDetailComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseItemDetailComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseItemDetailComponentInner(ClaimResponse.ItemDetailComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkIdElement()) {
      composePositiveIntCore("sequenceLinkId", element.getSequenceLinkIdElement(), false);
      composePositiveIntExtras("sequenceLinkId", element.getSequenceLinkIdElement(), false);
    }
    if (element.hasAdjudication()) {
      openArray("adjudication");
      for (ClaimResponse.DetailAdjudicationComponent e : element.getAdjudication())
        composeClaimResponseDetailAdjudicationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSubDetail()) {
      openArray("subDetail");
      for (ClaimResponse.SubDetailComponent e : element.getSubDetail())
        composeClaimResponseSubDetailComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseDetailAdjudicationComponent(String name,
      ClaimResponse.DetailAdjudicationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseDetailAdjudicationComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseDetailAdjudicationComponentInner(ClaimResponse.DetailAdjudicationComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeClaimResponseSubDetailComponent(String name, ClaimResponse.SubDetailComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseSubDetailComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseSubDetailComponentInner(ClaimResponse.SubDetailComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkIdElement()) {
      composePositiveIntCore("sequenceLinkId", element.getSequenceLinkIdElement(), false);
      composePositiveIntExtras("sequenceLinkId", element.getSequenceLinkIdElement(), false);
    }
    if (element.hasAdjudication()) {
      openArray("adjudication");
      for (ClaimResponse.SubdetailAdjudicationComponent e : element.getAdjudication())
        composeClaimResponseSubdetailAdjudicationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseSubdetailAdjudicationComponent(String name,
      ClaimResponse.SubdetailAdjudicationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseSubdetailAdjudicationComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseSubdetailAdjudicationComponentInner(
      ClaimResponse.SubdetailAdjudicationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeClaimResponseAddedItemComponent(String name, ClaimResponse.AddedItemComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseAddedItemComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseAddedItemComponentInner(ClaimResponse.AddedItemComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkId()) {
      openArray("sequenceLinkId");
      for (PositiveIntType e : element.getSequenceLinkId())
        composePositiveIntCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getSequenceLinkId())) {
        openArray("_sequenceLinkId");
        for (PositiveIntType e : element.getSequenceLinkId())
          composePositiveIntExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasService()) {
      composeCoding("service", element.getService());
    }
    if (element.hasFee()) {
      composeMoney("fee", element.getFee());
    }
    if (element.hasNoteNumberLinkId()) {
      openArray("noteNumberLinkId");
      for (PositiveIntType e : element.getNoteNumberLinkId())
        composePositiveIntCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getNoteNumberLinkId())) {
        openArray("_noteNumberLinkId");
        for (PositiveIntType e : element.getNoteNumberLinkId())
          composePositiveIntExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasAdjudication()) {
      openArray("adjudication");
      for (ClaimResponse.AddedItemAdjudicationComponent e : element.getAdjudication())
        composeClaimResponseAddedItemAdjudicationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDetail()) {
      openArray("detail");
      for (ClaimResponse.AddedItemsDetailComponent e : element.getDetail())
        composeClaimResponseAddedItemsDetailComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseAddedItemAdjudicationComponent(String name,
      ClaimResponse.AddedItemAdjudicationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseAddedItemAdjudicationComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseAddedItemAdjudicationComponentInner(
      ClaimResponse.AddedItemAdjudicationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeClaimResponseAddedItemsDetailComponent(String name,
      ClaimResponse.AddedItemsDetailComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseAddedItemsDetailComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseAddedItemsDetailComponentInner(ClaimResponse.AddedItemsDetailComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasService()) {
      composeCoding("service", element.getService());
    }
    if (element.hasFee()) {
      composeMoney("fee", element.getFee());
    }
    if (element.hasAdjudication()) {
      openArray("adjudication");
      for (ClaimResponse.AddedItemDetailAdjudicationComponent e : element.getAdjudication())
        composeClaimResponseAddedItemDetailAdjudicationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClaimResponseAddedItemDetailAdjudicationComponent(String name,
      ClaimResponse.AddedItemDetailAdjudicationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseAddedItemDetailAdjudicationComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseAddedItemDetailAdjudicationComponentInner(
      ClaimResponse.AddedItemDetailAdjudicationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
    if (element.hasValueElement()) {
      composeDecimalCore("value", element.getValueElement(), false);
      composeDecimalExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeClaimResponseErrorsComponent(String name, ClaimResponse.ErrorsComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseErrorsComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseErrorsComponentInner(ClaimResponse.ErrorsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkIdElement()) {
      composePositiveIntCore("sequenceLinkId", element.getSequenceLinkIdElement(), false);
      composePositiveIntExtras("sequenceLinkId", element.getSequenceLinkIdElement(), false);
    }
    if (element.hasDetailSequenceLinkIdElement()) {
      composePositiveIntCore("detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), false);
      composePositiveIntExtras("detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), false);
    }
    if (element.hasSubdetailSequenceLinkIdElement()) {
      composePositiveIntCore("subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), false);
      composePositiveIntExtras("subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), false);
    }
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
  }

  protected void composeClaimResponseNotesComponent(String name, ClaimResponse.NotesComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseNotesComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseNotesComponentInner(ClaimResponse.NotesComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNumberElement()) {
      composePositiveIntCore("number", element.getNumberElement(), false);
      composePositiveIntExtras("number", element.getNumberElement(), false);
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composeClaimResponseCoverageComponent(String name, ClaimResponse.CoverageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeClaimResponseCoverageComponentInner(element);
      close();
    }
  }

  protected void composeClaimResponseCoverageComponentInner(ClaimResponse.CoverageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasFocalElement()) {
      composeBooleanCore("focal", element.getFocalElement(), false);
      composeBooleanExtras("focal", element.getFocalElement(), false);
    }
    if (element.hasCoverage()) {
      composeReference("coverage", element.getCoverage());
    }
    if (element.hasBusinessArrangementElement()) {
      composeStringCore("businessArrangement", element.getBusinessArrangementElement(), false);
      composeStringExtras("businessArrangement", element.getBusinessArrangementElement(), false);
    }
    if (element.hasRelationship()) {
      composeCoding("relationship", element.getRelationship());
    }
    if (element.hasPreAuthRef()) {
      openArray("preAuthRef");
      for (StringType e : element.getPreAuthRef())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPreAuthRef())) {
        openArray("_preAuthRef");
        for (StringType e : element.getPreAuthRef())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasClaimResponse()) {
      composeReference("claimResponse", element.getClaimResponse());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
  }

  protected void composeClinicalImpression(String name, ClinicalImpression element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeClinicalImpressionInner(element);
    }
  }

  protected void composeClinicalImpressionInner(ClinicalImpression element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasAssessor()) {
      composeReference("assessor", element.getAssessor());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new ClinicalImpression.ClinicalImpressionStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new ClinicalImpression.ClinicalImpressionStatusEnumFactory(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasPrevious()) {
      composeReference("previous", element.getPrevious());
    }
    if (element.hasProblem()) {
      openArray("problem");
      for (Reference e : element.getProblem())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasTrigger()) {
      composeType("trigger", element.getTrigger());
    }
    if (element.hasInvestigations()) {
      openArray("investigations");
      for (ClinicalImpression.ClinicalImpressionInvestigationsComponent e : element.getInvestigations())
        composeClinicalImpressionClinicalImpressionInvestigationsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasProtocolElement()) {
      composeUriCore("protocol", element.getProtocolElement(), false);
      composeUriExtras("protocol", element.getProtocolElement(), false);
    }
    if (element.hasSummaryElement()) {
      composeStringCore("summary", element.getSummaryElement(), false);
      composeStringExtras("summary", element.getSummaryElement(), false);
    }
    if (element.hasFinding()) {
      openArray("finding");
      for (ClinicalImpression.ClinicalImpressionFindingComponent e : element.getFinding())
        composeClinicalImpressionClinicalImpressionFindingComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasResolved()) {
      openArray("resolved");
      for (CodeableConcept e : element.getResolved())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRuledOut()) {
      openArray("ruledOut");
      for (ClinicalImpression.ClinicalImpressionRuledOutComponent e : element.getRuledOut())
        composeClinicalImpressionClinicalImpressionRuledOutComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasPrognosisElement()) {
      composeStringCore("prognosis", element.getPrognosisElement(), false);
      composeStringExtras("prognosis", element.getPrognosisElement(), false);
    }
    if (element.hasPlan()) {
      openArray("plan");
      for (Reference e : element.getPlan())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasAction()) {
      openArray("action");
      for (Reference e : element.getAction())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClinicalImpressionClinicalImpressionInvestigationsComponent(String name,
      ClinicalImpression.ClinicalImpressionInvestigationsComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClinicalImpressionClinicalImpressionInvestigationsComponentInner(element);
      close();
    }
  }

  protected void composeClinicalImpressionClinicalImpressionInvestigationsComponentInner(
      ClinicalImpression.ClinicalImpressionInvestigationsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasItem()) {
      openArray("item");
      for (Reference e : element.getItem())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeClinicalImpressionClinicalImpressionFindingComponent(String name,
      ClinicalImpression.ClinicalImpressionFindingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClinicalImpressionClinicalImpressionFindingComponentInner(element);
      close();
    }
  }

  protected void composeClinicalImpressionClinicalImpressionFindingComponentInner(
      ClinicalImpression.ClinicalImpressionFindingComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasItem()) {
      composeCodeableConcept("item", element.getItem());
    }
    if (element.hasCauseElement()) {
      composeStringCore("cause", element.getCauseElement(), false);
      composeStringExtras("cause", element.getCauseElement(), false);
    }
  }

  protected void composeClinicalImpressionClinicalImpressionRuledOutComponent(String name,
      ClinicalImpression.ClinicalImpressionRuledOutComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeClinicalImpressionClinicalImpressionRuledOutComponentInner(element);
      close();
    }
  }

  protected void composeClinicalImpressionClinicalImpressionRuledOutComponentInner(
      ClinicalImpression.ClinicalImpressionRuledOutComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasItem()) {
      composeCodeableConcept("item", element.getItem());
    }
    if (element.hasReasonElement()) {
      composeStringCore("reason", element.getReasonElement(), false);
      composeStringExtras("reason", element.getReasonElement(), false);
    }
  }

  protected void composeCommunication(String name, Communication element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeCommunicationInner(element);
    }
  }

  protected void composeCommunicationInner(Communication element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasSender()) {
      composeReference("sender", element.getSender());
    }
    if (element.hasRecipient()) {
      openArray("recipient");
      for (Reference e : element.getRecipient())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasPayload()) {
      openArray("payload");
      for (Communication.CommunicationPayloadComponent e : element.getPayload())
        composeCommunicationCommunicationPayloadComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMedium()) {
      openArray("medium");
      for (CodeableConcept e : element.getMedium())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Communication.CommunicationStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Communication.CommunicationStatusEnumFactory(),
          false);
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasSentElement()) {
      composeDateTimeCore("sent", element.getSentElement(), false);
      composeDateTimeExtras("sent", element.getSentElement(), false);
    }
    if (element.hasReceivedElement()) {
      composeDateTimeCore("received", element.getReceivedElement(), false);
      composeDateTimeExtras("received", element.getReceivedElement(), false);
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasRequestDetail()) {
      composeReference("requestDetail", element.getRequestDetail());
    }
  }

  protected void composeCommunicationCommunicationPayloadComponent(String name,
      Communication.CommunicationPayloadComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeCommunicationCommunicationPayloadComponentInner(element);
      close();
    }
  }

  protected void composeCommunicationCommunicationPayloadComponentInner(
      Communication.CommunicationPayloadComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasContent()) {
      composeType("content", element.getContent());
    }
  }

  protected void composeCommunicationRequest(String name, CommunicationRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeCommunicationRequestInner(element);
    }
  }

  protected void composeCommunicationRequestInner(CommunicationRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasSender()) {
      composeReference("sender", element.getSender());
    }
    if (element.hasRecipient()) {
      openArray("recipient");
      for (Reference e : element.getRecipient())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasPayload()) {
      openArray("payload");
      for (CommunicationRequest.CommunicationRequestPayloadComponent e : element.getPayload())
        composeCommunicationRequestCommunicationRequestPayloadComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMedium()) {
      openArray("medium");
      for (CodeableConcept e : element.getMedium())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequester()) {
      composeReference("requester", element.getRequester());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new CommunicationRequest.CommunicationRequestStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new CommunicationRequest.CommunicationRequestStatusEnumFactory(), false);
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasScheduled()) {
      composeType("scheduled", element.getScheduled());
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequestedOnElement()) {
      composeDateTimeCore("requestedOn", element.getRequestedOnElement(), false);
      composeDateTimeExtras("requestedOn", element.getRequestedOnElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasPriority()) {
      composeCodeableConcept("priority", element.getPriority());
    }
  }

  protected void composeCommunicationRequestCommunicationRequestPayloadComponent(String name,
      CommunicationRequest.CommunicationRequestPayloadComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeCommunicationRequestCommunicationRequestPayloadComponentInner(element);
      close();
    }
  }

  protected void composeCommunicationRequestCommunicationRequestPayloadComponentInner(
      CommunicationRequest.CommunicationRequestPayloadComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasContent()) {
      composeType("content", element.getContent());
    }
  }

  protected void composeComposition(String name, Composition element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeCompositionInner(element);
    }
  }

  protected void composeCompositionInner(Composition element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasClass_()) {
      composeCodeableConcept("class", element.getClass_());
    }
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Composition.CompositionStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Composition.CompositionStatusEnumFactory(),
          false);
    }
    if (element.hasConfidentialityElement()) {
      composeCodeCore("confidentiality", element.getConfidentialityElement(), false);
      composeCodeExtras("confidentiality", element.getConfidentialityElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasAuthor()) {
      openArray("author");
      for (Reference e : element.getAuthor())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasAttester()) {
      openArray("attester");
      for (Composition.CompositionAttesterComponent e : element.getAttester())
        composeCompositionCompositionAttesterComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCustodian()) {
      composeReference("custodian", element.getCustodian());
    }
    if (element.hasEvent()) {
      openArray("event");
      for (Composition.CompositionEventComponent e : element.getEvent())
        composeCompositionCompositionEventComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasSection()) {
      openArray("section");
      for (Composition.SectionComponent e : element.getSection())
        composeCompositionSectionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeCompositionCompositionAttesterComponent(String name,
      Composition.CompositionAttesterComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeCompositionCompositionAttesterComponentInner(element);
      close();
    }
  }

  protected void composeCompositionCompositionAttesterComponentInner(Composition.CompositionAttesterComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasMode()) {
      openArray("mode");
      for (Enumeration<Composition.CompositionAttestationMode> e : element.getMode())
        composeEnumerationCore(null, e, new Composition.CompositionAttestationModeEnumFactory(), true);
      closeArray();
      if (anyHasExtras(element.getMode())) {
        openArray("_mode");
        for (Enumeration<Composition.CompositionAttestationMode> e : element.getMode())
          composeEnumerationExtras(null, e, new Composition.CompositionAttestationModeEnumFactory(), true);
        closeArray();
      }
    }
    ;
    if (element.hasTimeElement()) {
      composeDateTimeCore("time", element.getTimeElement(), false);
      composeDateTimeExtras("time", element.getTimeElement(), false);
    }
    if (element.hasParty()) {
      composeReference("party", element.getParty());
    }
  }

  protected void composeCompositionCompositionEventComponent(String name, Composition.CompositionEventComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeCompositionCompositionEventComponentInner(element);
      close();
    }
  }

  protected void composeCompositionCompositionEventComponentInner(Composition.CompositionEventComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      openArray("code");
      for (CodeableConcept e : element.getCode())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasDetail()) {
      openArray("detail");
      for (Reference e : element.getDetail())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeCompositionSectionComponent(String name, Composition.SectionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeCompositionSectionComponentInner(element);
      close();
    }
  }

  protected void composeCompositionSectionComponentInner(Composition.SectionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasText()) {
      composeNarrative("text", element.getText());
    }
    if (element.hasModeElement()) {
      composeCodeCore("mode", element.getModeElement(), false);
      composeCodeExtras("mode", element.getModeElement(), false);
    }
    if (element.hasOrderedBy()) {
      composeCodeableConcept("orderedBy", element.getOrderedBy());
    }
    if (element.hasEntry()) {
      openArray("entry");
      for (Reference e : element.getEntry())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasEmptyReason()) {
      composeCodeableConcept("emptyReason", element.getEmptyReason());
    }
    if (element.hasSection()) {
      openArray("section");
      for (Composition.SectionComponent e : element.getSection())
        composeCompositionSectionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConceptMap(String name, ConceptMap element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeConceptMapInner(element);
    }
  }

  protected void composeConceptMapInner(ConceptMap element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (ConceptMap.ConceptMapContactComponent e : element.getContact())
        composeConceptMapConceptMapContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasSource()) {
      composeType("source", element.getSource());
    }
    if (element.hasTarget()) {
      composeType("target", element.getTarget());
    }
    if (element.hasElement()) {
      openArray("element");
      for (ConceptMap.SourceElementComponent e : element.getElement())
        composeConceptMapSourceElementComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConceptMapConceptMapContactComponent(String name, ConceptMap.ConceptMapContactComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConceptMapConceptMapContactComponentInner(element);
      close();
    }
  }

  protected void composeConceptMapConceptMapContactComponentInner(ConceptMap.ConceptMapContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConceptMapSourceElementComponent(String name, ConceptMap.SourceElementComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConceptMapSourceElementComponentInner(element);
      close();
    }
  }

  protected void composeConceptMapSourceElementComponentInner(ConceptMap.SourceElementComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeSystemElement()) {
      composeUriCore("codeSystem", element.getCodeSystemElement(), false);
      composeUriExtras("codeSystem", element.getCodeSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasTarget()) {
      openArray("target");
      for (ConceptMap.TargetElementComponent e : element.getTarget())
        composeConceptMapTargetElementComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConceptMapTargetElementComponent(String name, ConceptMap.TargetElementComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConceptMapTargetElementComponentInner(element);
      close();
    }
  }

  protected void composeConceptMapTargetElementComponentInner(ConceptMap.TargetElementComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeSystemElement()) {
      composeUriCore("codeSystem", element.getCodeSystemElement(), false);
      composeUriExtras("codeSystem", element.getCodeSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasEquivalenceElement()) {
      composeEnumerationCore("equivalence", element.getEquivalenceElement(),
          new Enumerations.ConceptMapEquivalenceEnumFactory(), false);
      composeEnumerationExtras("equivalence", element.getEquivalenceElement(),
          new Enumerations.ConceptMapEquivalenceEnumFactory(), false);
    }
    if (element.hasCommentsElement()) {
      composeStringCore("comments", element.getCommentsElement(), false);
      composeStringExtras("comments", element.getCommentsElement(), false);
    }
    if (element.hasDependsOn()) {
      openArray("dependsOn");
      for (ConceptMap.OtherElementComponent e : element.getDependsOn())
        composeConceptMapOtherElementComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasProduct()) {
      openArray("product");
      for (ConceptMap.OtherElementComponent e : element.getProduct())
        composeConceptMapOtherElementComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConceptMapOtherElementComponent(String name, ConceptMap.OtherElementComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConceptMapOtherElementComponentInner(element);
      close();
    }
  }

  protected void composeConceptMapOtherElementComponentInner(ConceptMap.OtherElementComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasElementElement()) {
      composeUriCore("element", element.getElementElement(), false);
      composeUriExtras("element", element.getElementElement(), false);
    }
    if (element.hasCodeSystemElement()) {
      composeUriCore("codeSystem", element.getCodeSystemElement(), false);
      composeUriExtras("codeSystem", element.getCodeSystemElement(), false);
    }
    if (element.hasCodeElement()) {
      composeStringCore("code", element.getCodeElement(), false);
      composeStringExtras("code", element.getCodeElement(), false);
    }
  }

  protected void composeCondition(String name, Condition element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeConditionInner(element);
    }
  }

  protected void composeConditionInner(Condition element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasAsserter()) {
      composeReference("asserter", element.getAsserter());
    }
    if (element.hasDateRecordedElement()) {
      composeDateCore("dateRecorded", element.getDateRecordedElement(), false);
      composeDateExtras("dateRecorded", element.getDateRecordedElement(), false);
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasClinicalStatusElement()) {
      composeCodeCore("clinicalStatus", element.getClinicalStatusElement(), false);
      composeCodeExtras("clinicalStatus", element.getClinicalStatusElement(), false);
    }
    if (element.hasVerificationStatusElement()) {
      composeEnumerationCore("verificationStatus", element.getVerificationStatusElement(),
          new Condition.ConditionVerificationStatusEnumFactory(), false);
      composeEnumerationExtras("verificationStatus", element.getVerificationStatusElement(),
          new Condition.ConditionVerificationStatusEnumFactory(), false);
    }
    if (element.hasSeverity()) {
      composeCodeableConcept("severity", element.getSeverity());
    }
    if (element.hasOnset()) {
      composeType("onset", element.getOnset());
    }
    if (element.hasAbatement()) {
      composeType("abatement", element.getAbatement());
    }
    if (element.hasStage()) {
      composeConditionConditionStageComponent("stage", element.getStage());
    }
    if (element.hasEvidence()) {
      openArray("evidence");
      for (Condition.ConditionEvidenceComponent e : element.getEvidence())
        composeConditionConditionEvidenceComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasBodySite()) {
      openArray("bodySite");
      for (CodeableConcept e : element.getBodySite())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasNotesElement()) {
      composeStringCore("notes", element.getNotesElement(), false);
      composeStringExtras("notes", element.getNotesElement(), false);
    }
  }

  protected void composeConditionConditionStageComponent(String name, Condition.ConditionStageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConditionConditionStageComponentInner(element);
      close();
    }
  }

  protected void composeConditionConditionStageComponentInner(Condition.ConditionStageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSummary()) {
      composeCodeableConcept("summary", element.getSummary());
    }
    if (element.hasAssessment()) {
      openArray("assessment");
      for (Reference e : element.getAssessment())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConditionConditionEvidenceComponent(String name, Condition.ConditionEvidenceComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConditionConditionEvidenceComponentInner(element);
      close();
    }
  }

  protected void composeConditionConditionEvidenceComponentInner(Condition.ConditionEvidenceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasDetail()) {
      openArray("detail");
      for (Reference e : element.getDetail())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformance(String name, Conformance element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeConformanceInner(element);
    }
  }

  protected void composeConformanceInner(Conformance element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (Conformance.ConformanceContactComponent e : element.getContact())
        composeConformanceConformanceContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasKindElement()) {
      composeEnumerationCore("kind", element.getKindElement(), new Conformance.ConformanceStatementKindEnumFactory(),
          false);
      composeEnumerationExtras("kind", element.getKindElement(), new Conformance.ConformanceStatementKindEnumFactory(),
          false);
    }
    if (element.hasSoftware()) {
      composeConformanceConformanceSoftwareComponent("software", element.getSoftware());
    }
    if (element.hasImplementation()) {
      composeConformanceConformanceImplementationComponent("implementation", element.getImplementation());
    }
    if (element.hasFhirVersionElement()) {
      composeIdCore("fhirVersion", element.getFhirVersionElement(), false);
      composeIdExtras("fhirVersion", element.getFhirVersionElement(), false);
    }
    if (element.hasAcceptUnknownElement()) {
      composeEnumerationCore("acceptUnknown", element.getAcceptUnknownElement(),
          new Conformance.UnknownContentCodeEnumFactory(), false);
      composeEnumerationExtras("acceptUnknown", element.getAcceptUnknownElement(),
          new Conformance.UnknownContentCodeEnumFactory(), false);
    }
    if (element.hasFormat()) {
      openArray("format");
      for (CodeType e : element.getFormat())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getFormat())) {
        openArray("_format");
        for (CodeType e : element.getFormat())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasProfile()) {
      openArray("profile");
      for (Reference e : element.getProfile())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasRest()) {
      openArray("rest");
      for (Conformance.ConformanceRestComponent e : element.getRest())
        composeConformanceConformanceRestComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMessaging()) {
      openArray("messaging");
      for (Conformance.ConformanceMessagingComponent e : element.getMessaging())
        composeConformanceConformanceMessagingComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDocument()) {
      openArray("document");
      for (Conformance.ConformanceDocumentComponent e : element.getDocument())
        composeConformanceConformanceDocumentComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformanceConformanceContactComponent(String name,
      Conformance.ConformanceContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceContactComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceContactComponentInner(Conformance.ConformanceContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformanceConformanceSoftwareComponent(String name,
      Conformance.ConformanceSoftwareComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceSoftwareComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceSoftwareComponentInner(Conformance.ConformanceSoftwareComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasReleaseDateElement()) {
      composeDateTimeCore("releaseDate", element.getReleaseDateElement(), false);
      composeDateTimeExtras("releaseDate", element.getReleaseDateElement(), false);
    }
  }

  protected void composeConformanceConformanceImplementationComponent(String name,
      Conformance.ConformanceImplementationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceImplementationComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceImplementationComponentInner(
      Conformance.ConformanceImplementationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
  }

  protected void composeConformanceConformanceRestComponent(String name, Conformance.ConformanceRestComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestComponentInner(Conformance.ConformanceRestComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new Conformance.RestfulConformanceModeEnumFactory(),
          false);
      composeEnumerationExtras("mode", element.getModeElement(), new Conformance.RestfulConformanceModeEnumFactory(),
          false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
    if (element.hasSecurity()) {
      composeConformanceConformanceRestSecurityComponent("security", element.getSecurity());
    }
    if (element.hasResource()) {
      openArray("resource");
      for (Conformance.ConformanceRestResourceComponent e : element.getResource())
        composeConformanceConformanceRestResourceComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasInteraction()) {
      openArray("interaction");
      for (Conformance.SystemInteractionComponent e : element.getInteraction())
        composeConformanceSystemInteractionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTransactionModeElement()) {
      composeEnumerationCore("transactionMode", element.getTransactionModeElement(),
          new Conformance.TransactionModeEnumFactory(), false);
      composeEnumerationExtras("transactionMode", element.getTransactionModeElement(),
          new Conformance.TransactionModeEnumFactory(), false);
    }
    if (element.hasSearchParam()) {
      openArray("searchParam");
      for (Conformance.ConformanceRestResourceSearchParamComponent e : element.getSearchParam())
        composeConformanceConformanceRestResourceSearchParamComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasOperation()) {
      openArray("operation");
      for (Conformance.ConformanceRestOperationComponent e : element.getOperation())
        composeConformanceConformanceRestOperationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCompartment()) {
      openArray("compartment");
      for (UriType e : element.getCompartment())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getCompartment())) {
        openArray("_compartment");
        for (UriType e : element.getCompartment())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
  }

  protected void composeConformanceConformanceRestSecurityComponent(String name,
      Conformance.ConformanceRestSecurityComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestSecurityComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestSecurityComponentInner(
      Conformance.ConformanceRestSecurityComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCorsElement()) {
      composeBooleanCore("cors", element.getCorsElement(), false);
      composeBooleanExtras("cors", element.getCorsElement(), false);
    }
    if (element.hasService()) {
      openArray("service");
      for (CodeableConcept e : element.getService())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasCertificate()) {
      openArray("certificate");
      for (Conformance.ConformanceRestSecurityCertificateComponent e : element.getCertificate())
        composeConformanceConformanceRestSecurityCertificateComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformanceConformanceRestSecurityCertificateComponent(String name,
      Conformance.ConformanceRestSecurityCertificateComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestSecurityCertificateComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestSecurityCertificateComponentInner(
      Conformance.ConformanceRestSecurityCertificateComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeCodeCore("type", element.getTypeElement(), false);
      composeCodeExtras("type", element.getTypeElement(), false);
    }
    if (element.hasBlobElement()) {
      composeBase64BinaryCore("blob", element.getBlobElement(), false);
      composeBase64BinaryExtras("blob", element.getBlobElement(), false);
    }
  }

  protected void composeConformanceConformanceRestResourceComponent(String name,
      Conformance.ConformanceRestResourceComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestResourceComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestResourceComponentInner(
      Conformance.ConformanceRestResourceComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeCodeCore("type", element.getTypeElement(), false);
      composeCodeExtras("type", element.getTypeElement(), false);
    }
    if (element.hasProfile()) {
      composeReference("profile", element.getProfile());
    }
    if (element.hasInteraction()) {
      openArray("interaction");
      for (Conformance.ResourceInteractionComponent e : element.getInteraction())
        composeConformanceResourceInteractionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasVersioningElement()) {
      composeEnumerationCore("versioning", element.getVersioningElement(),
          new Conformance.ResourceVersionPolicyEnumFactory(), false);
      composeEnumerationExtras("versioning", element.getVersioningElement(),
          new Conformance.ResourceVersionPolicyEnumFactory(), false);
    }
    if (element.hasReadHistoryElement()) {
      composeBooleanCore("readHistory", element.getReadHistoryElement(), false);
      composeBooleanExtras("readHistory", element.getReadHistoryElement(), false);
    }
    if (element.hasUpdateCreateElement()) {
      composeBooleanCore("updateCreate", element.getUpdateCreateElement(), false);
      composeBooleanExtras("updateCreate", element.getUpdateCreateElement(), false);
    }
    if (element.hasConditionalCreateElement()) {
      composeBooleanCore("conditionalCreate", element.getConditionalCreateElement(), false);
      composeBooleanExtras("conditionalCreate", element.getConditionalCreateElement(), false);
    }
    if (element.hasConditionalUpdateElement()) {
      composeBooleanCore("conditionalUpdate", element.getConditionalUpdateElement(), false);
      composeBooleanExtras("conditionalUpdate", element.getConditionalUpdateElement(), false);
    }
    if (element.hasConditionalDeleteElement()) {
      composeEnumerationCore("conditionalDelete", element.getConditionalDeleteElement(),
          new Conformance.ConditionalDeleteStatusEnumFactory(), false);
      composeEnumerationExtras("conditionalDelete", element.getConditionalDeleteElement(),
          new Conformance.ConditionalDeleteStatusEnumFactory(), false);
    }
    if (element.hasSearchInclude()) {
      openArray("searchInclude");
      for (StringType e : element.getSearchInclude())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getSearchInclude())) {
        openArray("_searchInclude");
        for (StringType e : element.getSearchInclude())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasSearchRevInclude()) {
      openArray("searchRevInclude");
      for (StringType e : element.getSearchRevInclude())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getSearchRevInclude())) {
        openArray("_searchRevInclude");
        for (StringType e : element.getSearchRevInclude())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasSearchParam()) {
      openArray("searchParam");
      for (Conformance.ConformanceRestResourceSearchParamComponent e : element.getSearchParam())
        composeConformanceConformanceRestResourceSearchParamComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformanceResourceInteractionComponent(String name,
      Conformance.ResourceInteractionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceResourceInteractionComponentInner(element);
      close();
    }
  }

  protected void composeConformanceResourceInteractionComponentInner(Conformance.ResourceInteractionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(), new Conformance.TypeRestfulInteractionEnumFactory(),
          false);
      composeEnumerationExtras("code", element.getCodeElement(), new Conformance.TypeRestfulInteractionEnumFactory(),
          false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
  }

  protected void composeConformanceConformanceRestResourceSearchParamComponent(String name,
      Conformance.ConformanceRestResourceSearchParamComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestResourceSearchParamComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestResourceSearchParamComponentInner(
      Conformance.ConformanceRestResourceSearchParamComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDefinitionElement()) {
      composeUriCore("definition", element.getDefinitionElement(), false);
      composeUriExtras("definition", element.getDefinitionElement(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory(), false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
    if (element.hasTarget()) {
      openArray("target");
      for (CodeType e : element.getTarget())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getTarget())) {
        openArray("_target");
        for (CodeType e : element.getTarget())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasModifier()) {
      openArray("modifier");
      for (Enumeration<Conformance.SearchModifierCode> e : element.getModifier())
        composeEnumerationCore(null, e, new Conformance.SearchModifierCodeEnumFactory(), true);
      closeArray();
      if (anyHasExtras(element.getModifier())) {
        openArray("_modifier");
        for (Enumeration<Conformance.SearchModifierCode> e : element.getModifier())
          composeEnumerationExtras(null, e, new Conformance.SearchModifierCodeEnumFactory(), true);
        closeArray();
      }
    }
    ;
    if (element.hasChain()) {
      openArray("chain");
      for (StringType e : element.getChain())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getChain())) {
        openArray("_chain");
        for (StringType e : element.getChain())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
  }

  protected void composeConformanceSystemInteractionComponent(String name,
      Conformance.SystemInteractionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceSystemInteractionComponentInner(element);
      close();
    }
  }

  protected void composeConformanceSystemInteractionComponentInner(Conformance.SystemInteractionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(), new Conformance.SystemRestfulInteractionEnumFactory(),
          false);
      composeEnumerationExtras("code", element.getCodeElement(), new Conformance.SystemRestfulInteractionEnumFactory(),
          false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
  }

  protected void composeConformanceConformanceRestOperationComponent(String name,
      Conformance.ConformanceRestOperationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceRestOperationComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceRestOperationComponentInner(
      Conformance.ConformanceRestOperationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDefinition()) {
      composeReference("definition", element.getDefinition());
    }
  }

  protected void composeConformanceConformanceMessagingComponent(String name,
      Conformance.ConformanceMessagingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceMessagingComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceMessagingComponentInner(Conformance.ConformanceMessagingComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasEndpoint()) {
      openArray("endpoint");
      for (Conformance.ConformanceMessagingEndpointComponent e : element.getEndpoint())
        composeConformanceConformanceMessagingEndpointComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasReliableCacheElement()) {
      composeUnsignedIntCore("reliableCache", element.getReliableCacheElement(), false);
      composeUnsignedIntExtras("reliableCache", element.getReliableCacheElement(), false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
    if (element.hasEvent()) {
      openArray("event");
      for (Conformance.ConformanceMessagingEventComponent e : element.getEvent())
        composeConformanceConformanceMessagingEventComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeConformanceConformanceMessagingEndpointComponent(String name,
      Conformance.ConformanceMessagingEndpointComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceMessagingEndpointComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceMessagingEndpointComponentInner(
      Conformance.ConformanceMessagingEndpointComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasProtocol()) {
      composeCoding("protocol", element.getProtocol());
    }
    if (element.hasAddressElement()) {
      composeUriCore("address", element.getAddressElement(), false);
      composeUriExtras("address", element.getAddressElement(), false);
    }
  }

  protected void composeConformanceConformanceMessagingEventComponent(String name,
      Conformance.ConformanceMessagingEventComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceMessagingEventComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceMessagingEventComponentInner(
      Conformance.ConformanceMessagingEventComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCoding("code", element.getCode());
    }
    if (element.hasCategoryElement()) {
      composeEnumerationCore("category", element.getCategoryElement(),
          new Conformance.MessageSignificanceCategoryEnumFactory(), false);
      composeEnumerationExtras("category", element.getCategoryElement(),
          new Conformance.MessageSignificanceCategoryEnumFactory(), false);
    }
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new Conformance.ConformanceEventModeEnumFactory(),
          false);
      composeEnumerationExtras("mode", element.getModeElement(), new Conformance.ConformanceEventModeEnumFactory(),
          false);
    }
    if (element.hasFocusElement()) {
      composeCodeCore("focus", element.getFocusElement(), false);
      composeCodeExtras("focus", element.getFocusElement(), false);
    }
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasResponse()) {
      composeReference("response", element.getResponse());
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
  }

  protected void composeConformanceConformanceDocumentComponent(String name,
      Conformance.ConformanceDocumentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeConformanceConformanceDocumentComponentInner(element);
      close();
    }
  }

  protected void composeConformanceConformanceDocumentComponentInner(Conformance.ConformanceDocumentComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new Conformance.DocumentModeEnumFactory(), false);
      composeEnumerationExtras("mode", element.getModeElement(), new Conformance.DocumentModeEnumFactory(), false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
    if (element.hasProfile()) {
      composeReference("profile", element.getProfile());
    }
  }

  protected void composeContract(String name, Contract element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeContractInner(element);
    }
  }

  protected void composeContractInner(Contract element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasIssuedElement()) {
      composeDateTimeCore("issued", element.getIssuedElement(), false);
      composeDateTimeExtras("issued", element.getIssuedElement(), false);
    }
    if (element.hasApplies()) {
      composePeriod("applies", element.getApplies());
    }
    if (element.hasSubject()) {
      openArray("subject");
      for (Reference e : element.getSubject())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasAuthority()) {
      openArray("authority");
      for (Reference e : element.getAuthority())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasDomain()) {
      openArray("domain");
      for (Reference e : element.getDomain())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSubType()) {
      openArray("subType");
      for (CodeableConcept e : element.getSubType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasAction()) {
      openArray("action");
      for (CodeableConcept e : element.getAction())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActionReason()) {
      openArray("actionReason");
      for (CodeableConcept e : element.getActionReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActor()) {
      openArray("actor");
      for (Contract.ActorComponent e : element.getActor())
        composeContractActorComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasValuedItem()) {
      openArray("valuedItem");
      for (Contract.ValuedItemComponent e : element.getValuedItem())
        composeContractValuedItemComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSigner()) {
      openArray("signer");
      for (Contract.SignatoryComponent e : element.getSigner())
        composeContractSignatoryComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTerm()) {
      openArray("term");
      for (Contract.TermComponent e : element.getTerm())
        composeContractTermComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasBinding()) {
      composeType("binding", element.getBinding());
    }
    if (element.hasFriendly()) {
      openArray("friendly");
      for (Contract.FriendlyLanguageComponent e : element.getFriendly())
        composeContractFriendlyLanguageComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasLegal()) {
      openArray("legal");
      for (Contract.LegalLanguageComponent e : element.getLegal())
        composeContractLegalLanguageComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasRule()) {
      openArray("rule");
      for (Contract.ComputableLanguageComponent e : element.getRule())
        composeContractComputableLanguageComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeContractActorComponent(String name, Contract.ActorComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeContractActorComponentInner(element);
      close();
    }
  }

  protected void composeContractActorComponentInner(Contract.ActorComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasEntity()) {
      composeReference("entity", element.getEntity());
    }
    if (element.hasRole()) {
      openArray("role");
      for (CodeableConcept e : element.getRole())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
  }

  protected void composeContractValuedItemComponent(String name, Contract.ValuedItemComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractValuedItemComponentInner(element);
      close();
    }
  }

  protected void composeContractValuedItemComponentInner(Contract.ValuedItemComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasEntity()) {
      composeType("entity", element.getEntity());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasEffectiveTimeElement()) {
      composeDateTimeCore("effectiveTime", element.getEffectiveTimeElement(), false);
      composeDateTimeExtras("effectiveTime", element.getEffectiveTimeElement(), false);
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasUnitPrice()) {
      composeMoney("unitPrice", element.getUnitPrice());
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasPointsElement()) {
      composeDecimalCore("points", element.getPointsElement(), false);
      composeDecimalExtras("points", element.getPointsElement(), false);
    }
    if (element.hasNet()) {
      composeMoney("net", element.getNet());
    }
  }

  protected void composeContractSignatoryComponent(String name, Contract.SignatoryComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractSignatoryComponentInner(element);
      close();
    }
  }

  protected void composeContractSignatoryComponentInner(Contract.SignatoryComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasParty()) {
      composeReference("party", element.getParty());
    }
    if (element.hasSignatureElement()) {
      composeStringCore("signature", element.getSignatureElement(), false);
      composeStringExtras("signature", element.getSignatureElement(), false);
    }
  }

  protected void composeContractTermComponent(String name, Contract.TermComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeContractTermComponentInner(element);
      close();
    }
  }

  protected void composeContractTermComponentInner(Contract.TermComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasIssuedElement()) {
      composeDateTimeCore("issued", element.getIssuedElement(), false);
      composeDateTimeExtras("issued", element.getIssuedElement(), false);
    }
    if (element.hasApplies()) {
      composePeriod("applies", element.getApplies());
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSubType()) {
      composeCodeableConcept("subType", element.getSubType());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasAction()) {
      openArray("action");
      for (CodeableConcept e : element.getAction())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActionReason()) {
      openArray("actionReason");
      for (CodeableConcept e : element.getActionReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActor()) {
      openArray("actor");
      for (Contract.TermActorComponent e : element.getActor())
        composeContractTermActorComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasValuedItem()) {
      openArray("valuedItem");
      for (Contract.TermValuedItemComponent e : element.getValuedItem())
        composeContractTermValuedItemComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasGroup()) {
      openArray("group");
      for (Contract.TermComponent e : element.getGroup())
        composeContractTermComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeContractTermActorComponent(String name, Contract.TermActorComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractTermActorComponentInner(element);
      close();
    }
  }

  protected void composeContractTermActorComponentInner(Contract.TermActorComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasEntity()) {
      composeReference("entity", element.getEntity());
    }
    if (element.hasRole()) {
      openArray("role");
      for (CodeableConcept e : element.getRole())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
  }

  protected void composeContractTermValuedItemComponent(String name, Contract.TermValuedItemComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractTermValuedItemComponentInner(element);
      close();
    }
  }

  protected void composeContractTermValuedItemComponentInner(Contract.TermValuedItemComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasEntity()) {
      composeType("entity", element.getEntity());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasEffectiveTimeElement()) {
      composeDateTimeCore("effectiveTime", element.getEffectiveTimeElement(), false);
      composeDateTimeExtras("effectiveTime", element.getEffectiveTimeElement(), false);
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasUnitPrice()) {
      composeMoney("unitPrice", element.getUnitPrice());
    }
    if (element.hasFactorElement()) {
      composeDecimalCore("factor", element.getFactorElement(), false);
      composeDecimalExtras("factor", element.getFactorElement(), false);
    }
    if (element.hasPointsElement()) {
      composeDecimalCore("points", element.getPointsElement(), false);
      composeDecimalExtras("points", element.getPointsElement(), false);
    }
    if (element.hasNet()) {
      composeMoney("net", element.getNet());
    }
  }

  protected void composeContractFriendlyLanguageComponent(String name, Contract.FriendlyLanguageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractFriendlyLanguageComponentInner(element);
      close();
    }
  }

  protected void composeContractFriendlyLanguageComponentInner(Contract.FriendlyLanguageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasContent()) {
      composeType("content", element.getContent());
    }
  }

  protected void composeContractLegalLanguageComponent(String name, Contract.LegalLanguageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractLegalLanguageComponentInner(element);
      close();
    }
  }

  protected void composeContractLegalLanguageComponentInner(Contract.LegalLanguageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasContent()) {
      composeType("content", element.getContent());
    }
  }

  protected void composeContractComputableLanguageComponent(String name, Contract.ComputableLanguageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeContractComputableLanguageComponentInner(element);
      close();
    }
  }

  protected void composeContractComputableLanguageComponentInner(Contract.ComputableLanguageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasContent()) {
      composeType("content", element.getContent());
    }
  }

  protected void composeCoverage(String name, Coverage element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeCoverageInner(element);
    }
  }

  protected void composeCoverageInner(Coverage element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIssuer()) {
      composeReference("issuer", element.getIssuer());
    }
    if (element.hasBin()) {
      composeIdentifier("bin", element.getBin());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasSubscriberId()) {
      composeIdentifier("subscriberId", element.getSubscriberId());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasGroupElement()) {
      composeStringCore("group", element.getGroupElement(), false);
      composeStringExtras("group", element.getGroupElement(), false);
    }
    if (element.hasPlanElement()) {
      composeStringCore("plan", element.getPlanElement(), false);
      composeStringExtras("plan", element.getPlanElement(), false);
    }
    if (element.hasSubPlanElement()) {
      composeStringCore("subPlan", element.getSubPlanElement(), false);
      composeStringExtras("subPlan", element.getSubPlanElement(), false);
    }
    if (element.hasDependentElement()) {
      composePositiveIntCore("dependent", element.getDependentElement(), false);
      composePositiveIntExtras("dependent", element.getDependentElement(), false);
    }
    if (element.hasSequenceElement()) {
      composePositiveIntCore("sequence", element.getSequenceElement(), false);
      composePositiveIntExtras("sequence", element.getSequenceElement(), false);
    }
    if (element.hasSubscriber()) {
      composeReference("subscriber", element.getSubscriber());
    }
    if (element.hasNetwork()) {
      composeIdentifier("network", element.getNetwork());
    }
    if (element.hasContract()) {
      openArray("contract");
      for (Reference e : element.getContract())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDataElement(String name, DataElement element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDataElementInner(element);
    }
  }

  protected void composeDataElementInner(DataElement element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (DataElement.DataElementContactComponent e : element.getContact())
        composeDataElementDataElementContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasStringencyElement()) {
      composeEnumerationCore("stringency", element.getStringencyElement(),
          new DataElement.DataElementStringencyEnumFactory(), false);
      composeEnumerationExtras("stringency", element.getStringencyElement(),
          new DataElement.DataElementStringencyEnumFactory(), false);
    }
    if (element.hasMapping()) {
      openArray("mapping");
      for (DataElement.DataElementMappingComponent e : element.getMapping())
        composeDataElementDataElementMappingComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasElement()) {
      openArray("element");
      for (ElementDefinition e : element.getElement())
        composeElementDefinition(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDataElementDataElementContactComponent(String name,
      DataElement.DataElementContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDataElementDataElementContactComponentInner(element);
      close();
    }
  }

  protected void composeDataElementDataElementContactComponentInner(DataElement.DataElementContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDataElementDataElementMappingComponent(String name,
      DataElement.DataElementMappingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDataElementDataElementMappingComponentInner(element);
      close();
    }
  }

  protected void composeDataElementDataElementMappingComponentInner(DataElement.DataElementMappingComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasIdentityElement()) {
      composeIdCore("identity", element.getIdentityElement(), false);
      composeIdExtras("identity", element.getIdentityElement(), false);
    }
    if (element.hasUriElement()) {
      composeUriCore("uri", element.getUriElement(), false);
      composeUriExtras("uri", element.getUriElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasCommentsElement()) {
      composeStringCore("comments", element.getCommentsElement(), false);
      composeStringExtras("comments", element.getCommentsElement(), false);
    }
  }

  protected void composeDetectedIssue(String name, DetectedIssue element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDetectedIssueInner(element);
    }
  }

  protected void composeDetectedIssueInner(DetectedIssue element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasSeverityElement()) {
      composeEnumerationCore("severity", element.getSeverityElement(),
          new DetectedIssue.DetectedIssueSeverityEnumFactory(), false);
      composeEnumerationExtras("severity", element.getSeverityElement(),
          new DetectedIssue.DetectedIssueSeverityEnumFactory(), false);
    }
    if (element.hasImplicated()) {
      openArray("implicated");
      for (Reference e : element.getImplicated())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasDetailElement()) {
      composeStringCore("detail", element.getDetailElement(), false);
      composeStringExtras("detail", element.getDetailElement(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasReferenceElement()) {
      composeUriCore("reference", element.getReferenceElement(), false);
      composeUriExtras("reference", element.getReferenceElement(), false);
    }
    if (element.hasMitigation()) {
      openArray("mitigation");
      for (DetectedIssue.DetectedIssueMitigationComponent e : element.getMitigation())
        composeDetectedIssueDetectedIssueMitigationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDetectedIssueDetectedIssueMitigationComponent(String name,
      DetectedIssue.DetectedIssueMitigationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDetectedIssueDetectedIssueMitigationComponentInner(element);
      close();
    }
  }

  protected void composeDetectedIssueDetectedIssueMitigationComponentInner(
      DetectedIssue.DetectedIssueMitigationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasAction()) {
      composeCodeableConcept("action", element.getAction());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
  }

  protected void composeDevice(String name, Device element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDeviceInner(element);
    }
  }

  protected void composeDeviceInner(Device element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasNote()) {
      openArray("note");
      for (Annotation e : element.getNote())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Device.DeviceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Device.DeviceStatusEnumFactory(), false);
    }
    if (element.hasManufacturerElement()) {
      composeStringCore("manufacturer", element.getManufacturerElement(), false);
      composeStringExtras("manufacturer", element.getManufacturerElement(), false);
    }
    if (element.hasModelElement()) {
      composeStringCore("model", element.getModelElement(), false);
      composeStringExtras("model", element.getModelElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasManufactureDateElement()) {
      composeDateTimeCore("manufactureDate", element.getManufactureDateElement(), false);
      composeDateTimeExtras("manufactureDate", element.getManufactureDateElement(), false);
    }
    if (element.hasExpiryElement()) {
      composeDateTimeCore("expiry", element.getExpiryElement(), false);
      composeDateTimeExtras("expiry", element.getExpiryElement(), false);
    }
    if (element.hasUdiElement()) {
      composeStringCore("udi", element.getUdiElement(), false);
      composeStringExtras("udi", element.getUdiElement(), false);
    }
    if (element.hasLotNumberElement()) {
      composeStringCore("lotNumber", element.getLotNumberElement(), false);
      composeStringExtras("lotNumber", element.getLotNumberElement(), false);
    }
    if (element.hasOwner()) {
      composeReference("owner", element.getOwner());
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasContact()) {
      openArray("contact");
      for (ContactPoint e : element.getContact())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
  }

  protected void composeDeviceComponent(String name, DeviceComponent element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDeviceComponentInner(element);
    }
  }

  protected void composeDeviceComponentInner(DeviceComponent element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasLastSystemChangeElement()) {
      composeInstantCore("lastSystemChange", element.getLastSystemChangeElement(), false);
      composeInstantExtras("lastSystemChange", element.getLastSystemChangeElement(), false);
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasParent()) {
      composeReference("parent", element.getParent());
    }
    if (element.hasOperationalStatus()) {
      openArray("operationalStatus");
      for (CodeableConcept e : element.getOperationalStatus())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasParameterGroup()) {
      composeCodeableConcept("parameterGroup", element.getParameterGroup());
    }
    if (element.hasMeasurementPrincipleElement()) {
      composeEnumerationCore("measurementPrinciple", element.getMeasurementPrincipleElement(),
          new DeviceComponent.MeasmntPrincipleEnumFactory(), false);
      composeEnumerationExtras("measurementPrinciple", element.getMeasurementPrincipleElement(),
          new DeviceComponent.MeasmntPrincipleEnumFactory(), false);
    }
    if (element.hasProductionSpecification()) {
      openArray("productionSpecification");
      for (DeviceComponent.DeviceComponentProductionSpecificationComponent e : element.getProductionSpecification())
        composeDeviceComponentDeviceComponentProductionSpecificationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasLanguageCode()) {
      composeCodeableConcept("languageCode", element.getLanguageCode());
    }
  }

  protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(String name,
      DeviceComponent.DeviceComponentProductionSpecificationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDeviceComponentDeviceComponentProductionSpecificationComponentInner(element);
      close();
    }
  }

  protected void composeDeviceComponentDeviceComponentProductionSpecificationComponentInner(
      DeviceComponent.DeviceComponentProductionSpecificationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSpecType()) {
      composeCodeableConcept("specType", element.getSpecType());
    }
    if (element.hasComponentId()) {
      composeIdentifier("componentId", element.getComponentId());
    }
    if (element.hasProductionSpecElement()) {
      composeStringCore("productionSpec", element.getProductionSpecElement(), false);
      composeStringExtras("productionSpec", element.getProductionSpecElement(), false);
    }
  }

  protected void composeDeviceMetric(String name, DeviceMetric element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDeviceMetricInner(element);
    }
  }

  protected void composeDeviceMetricInner(DeviceMetric element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasUnit()) {
      composeCodeableConcept("unit", element.getUnit());
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasParent()) {
      composeReference("parent", element.getParent());
    }
    if (element.hasOperationalStatusElement()) {
      composeEnumerationCore("operationalStatus", element.getOperationalStatusElement(),
          new DeviceMetric.DeviceMetricOperationalStatusEnumFactory(), false);
      composeEnumerationExtras("operationalStatus", element.getOperationalStatusElement(),
          new DeviceMetric.DeviceMetricOperationalStatusEnumFactory(), false);
    }
    if (element.hasColorElement()) {
      composeEnumerationCore("color", element.getColorElement(), new DeviceMetric.DeviceMetricColorEnumFactory(),
          false);
      composeEnumerationExtras("color", element.getColorElement(), new DeviceMetric.DeviceMetricColorEnumFactory(),
          false);
    }
    if (element.hasCategoryElement()) {
      composeEnumerationCore("category", element.getCategoryElement(),
          new DeviceMetric.DeviceMetricCategoryEnumFactory(), false);
      composeEnumerationExtras("category", element.getCategoryElement(),
          new DeviceMetric.DeviceMetricCategoryEnumFactory(), false);
    }
    if (element.hasMeasurementPeriod()) {
      composeTiming("measurementPeriod", element.getMeasurementPeriod());
    }
    if (element.hasCalibration()) {
      openArray("calibration");
      for (DeviceMetric.DeviceMetricCalibrationComponent e : element.getCalibration())
        composeDeviceMetricDeviceMetricCalibrationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDeviceMetricDeviceMetricCalibrationComponent(String name,
      DeviceMetric.DeviceMetricCalibrationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDeviceMetricDeviceMetricCalibrationComponentInner(element);
      close();
    }
  }

  protected void composeDeviceMetricDeviceMetricCalibrationComponentInner(
      DeviceMetric.DeviceMetricCalibrationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(),
          new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory(), false);
    }
    if (element.hasStateElement()) {
      composeEnumerationCore("state", element.getStateElement(),
          new DeviceMetric.DeviceMetricCalibrationStateEnumFactory(), false);
      composeEnumerationExtras("state", element.getStateElement(),
          new DeviceMetric.DeviceMetricCalibrationStateEnumFactory(), false);
    }
    if (element.hasTimeElement()) {
      composeInstantCore("time", element.getTimeElement(), false);
      composeInstantExtras("time", element.getTimeElement(), false);
    }
  }

  protected void composeDeviceUseRequest(String name, DeviceUseRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDeviceUseRequestInner(element);
    }
  }

  protected void composeDeviceUseRequestInner(DeviceUseRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasBodySite()) {
      composeType("bodySite", element.getBodySite());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new DeviceUseRequest.DeviceUseRequestStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new DeviceUseRequest.DeviceUseRequestStatusEnumFactory(), false);
    }
    if (element.hasDevice()) {
      composeReference("device", element.getDevice());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasIndication()) {
      openArray("indication");
      for (CodeableConcept e : element.getIndication())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasNotes()) {
      openArray("notes");
      for (StringType e : element.getNotes())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getNotes())) {
        openArray("_notes");
        for (StringType e : element.getNotes())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPrnReason()) {
      openArray("prnReason");
      for (CodeableConcept e : element.getPrnReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasOrderedOnElement()) {
      composeDateTimeCore("orderedOn", element.getOrderedOnElement(), false);
      composeDateTimeExtras("orderedOn", element.getOrderedOnElement(), false);
    }
    if (element.hasRecordedOnElement()) {
      composeDateTimeCore("recordedOn", element.getRecordedOnElement(), false);
      composeDateTimeExtras("recordedOn", element.getRecordedOnElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasTiming()) {
      composeType("timing", element.getTiming());
    }
    if (element.hasPriorityElement()) {
      composeEnumerationCore("priority", element.getPriorityElement(),
          new DeviceUseRequest.DeviceUseRequestPriorityEnumFactory(), false);
      composeEnumerationExtras("priority", element.getPriorityElement(),
          new DeviceUseRequest.DeviceUseRequestPriorityEnumFactory(), false);
    }
  }

  protected void composeDeviceUseStatement(String name, DeviceUseStatement element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDeviceUseStatementInner(element);
    }
  }

  protected void composeDeviceUseStatementInner(DeviceUseStatement element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasBodySite()) {
      composeType("bodySite", element.getBodySite());
    }
    if (element.hasWhenUsed()) {
      composePeriod("whenUsed", element.getWhenUsed());
    }
    if (element.hasDevice()) {
      composeReference("device", element.getDevice());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasIndication()) {
      openArray("indication");
      for (CodeableConcept e : element.getIndication())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasNotes()) {
      openArray("notes");
      for (StringType e : element.getNotes())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getNotes())) {
        openArray("_notes");
        for (StringType e : element.getNotes())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasRecordedOnElement()) {
      composeDateTimeCore("recordedOn", element.getRecordedOnElement(), false);
      composeDateTimeExtras("recordedOn", element.getRecordedOnElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasTiming()) {
      composeType("timing", element.getTiming());
    }
  }

  protected void composeDiagnosticOrder(String name, DiagnosticOrder element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDiagnosticOrderInner(element);
    }
  }

  protected void composeDiagnosticOrderInner(DiagnosticOrder element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasOrderer()) {
      composeReference("orderer", element.getOrderer());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSupportingInformation()) {
      openArray("supportingInformation");
      for (Reference e : element.getSupportingInformation())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasSpecimen()) {
      openArray("specimen");
      for (Reference e : element.getSpecimen())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
    }
    if (element.hasPriorityElement()) {
      composeEnumerationCore("priority", element.getPriorityElement(),
          new DiagnosticOrder.DiagnosticOrderPriorityEnumFactory(), false);
      composeEnumerationExtras("priority", element.getPriorityElement(),
          new DiagnosticOrder.DiagnosticOrderPriorityEnumFactory(), false);
    }
    if (element.hasEvent()) {
      openArray("event");
      for (DiagnosticOrder.DiagnosticOrderEventComponent e : element.getEvent())
        composeDiagnosticOrderDiagnosticOrderEventComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasItem()) {
      openArray("item");
      for (DiagnosticOrder.DiagnosticOrderItemComponent e : element.getItem())
        composeDiagnosticOrderDiagnosticOrderItemComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasNote()) {
      openArray("note");
      for (Annotation e : element.getNote())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDiagnosticOrderDiagnosticOrderEventComponent(String name,
      DiagnosticOrder.DiagnosticOrderEventComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDiagnosticOrderDiagnosticOrderEventComponentInner(element);
      close();
    }
  }

  protected void composeDiagnosticOrderDiagnosticOrderEventComponentInner(
      DiagnosticOrder.DiagnosticOrderEventComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
    }
    if (element.hasDescription()) {
      composeCodeableConcept("description", element.getDescription());
    }
    if (element.hasDateTimeElement()) {
      composeDateTimeCore("dateTime", element.getDateTimeElement(), false);
      composeDateTimeExtras("dateTime", element.getDateTimeElement(), false);
    }
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
  }

  protected void composeDiagnosticOrderDiagnosticOrderItemComponent(String name,
      DiagnosticOrder.DiagnosticOrderItemComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDiagnosticOrderDiagnosticOrderItemComponentInner(element);
      close();
    }
  }

  protected void composeDiagnosticOrderDiagnosticOrderItemComponentInner(
      DiagnosticOrder.DiagnosticOrderItemComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSpecimen()) {
      openArray("specimen");
      for (Reference e : element.getSpecimen())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasBodySite()) {
      composeCodeableConcept("bodySite", element.getBodySite());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new DiagnosticOrder.DiagnosticOrderStatusEnumFactory(), false);
    }
    if (element.hasEvent()) {
      openArray("event");
      for (DiagnosticOrder.DiagnosticOrderEventComponent e : element.getEvent())
        composeDiagnosticOrderDiagnosticOrderEventComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDiagnosticReport(String name, DiagnosticReport element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDiagnosticReportInner(element);
    }
  }

  protected void composeDiagnosticReportInner(DiagnosticReport element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new DiagnosticReport.DiagnosticReportStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new DiagnosticReport.DiagnosticReportStatusEnumFactory(), false);
    }
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasEffective()) {
      composeType("effective", element.getEffective());
    }
    if (element.hasIssuedElement()) {
      composeInstantCore("issued", element.getIssuedElement(), false);
      composeInstantExtras("issued", element.getIssuedElement(), false);
    }
    if (element.hasPerformer()) {
      composeReference("performer", element.getPerformer());
    }
    if (element.hasRequest()) {
      openArray("request");
      for (Reference e : element.getRequest())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasSpecimen()) {
      openArray("specimen");
      for (Reference e : element.getSpecimen())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasResult()) {
      openArray("result");
      for (Reference e : element.getResult())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasImagingStudy()) {
      openArray("imagingStudy");
      for (Reference e : element.getImagingStudy())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasImage()) {
      openArray("image");
      for (DiagnosticReport.DiagnosticReportImageComponent e : element.getImage())
        composeDiagnosticReportDiagnosticReportImageComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasConclusionElement()) {
      composeStringCore("conclusion", element.getConclusionElement(), false);
      composeStringExtras("conclusion", element.getConclusionElement(), false);
    }
    if (element.hasCodedDiagnosis()) {
      openArray("codedDiagnosis");
      for (CodeableConcept e : element.getCodedDiagnosis())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPresentedForm()) {
      openArray("presentedForm");
      for (Attachment e : element.getPresentedForm())
        composeAttachment(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDiagnosticReportDiagnosticReportImageComponent(String name,
      DiagnosticReport.DiagnosticReportImageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDiagnosticReportDiagnosticReportImageComponentInner(element);
      close();
    }
  }

  protected void composeDiagnosticReportDiagnosticReportImageComponentInner(
      DiagnosticReport.DiagnosticReportImageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
    if (element.hasLink()) {
      composeReference("link", element.getLink());
    }
  }

  protected void composeDocumentManifest(String name, DocumentManifest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDocumentManifestInner(element);
    }
  }

  protected void composeDocumentManifestInner(DocumentManifest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasMasterIdentifier()) {
      composeIdentifier("masterIdentifier", element.getMasterIdentifier());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasRecipient()) {
      openArray("recipient");
      for (Reference e : element.getRecipient())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasAuthor()) {
      openArray("author");
      for (Reference e : element.getAuthor())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasSourceElement()) {
      composeUriCore("source", element.getSourceElement(), false);
      composeUriExtras("source", element.getSourceElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.DocumentReferenceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.DocumentReferenceStatusEnumFactory(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasContent()) {
      openArray("content");
      for (DocumentManifest.DocumentManifestContentComponent e : element.getContent())
        composeDocumentManifestDocumentManifestContentComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasRelated()) {
      openArray("related");
      for (DocumentManifest.DocumentManifestRelatedComponent e : element.getRelated())
        composeDocumentManifestDocumentManifestRelatedComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDocumentManifestDocumentManifestContentComponent(String name,
      DocumentManifest.DocumentManifestContentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentManifestDocumentManifestContentComponentInner(element);
      close();
    }
  }

  protected void composeDocumentManifestDocumentManifestContentComponentInner(
      DocumentManifest.DocumentManifestContentComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasP()) {
      composeType("p", element.getP());
    }
  }

  protected void composeDocumentManifestDocumentManifestRelatedComponent(String name,
      DocumentManifest.DocumentManifestRelatedComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentManifestDocumentManifestRelatedComponentInner(element);
      close();
    }
  }

  protected void composeDocumentManifestDocumentManifestRelatedComponentInner(
      DocumentManifest.DocumentManifestRelatedComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasRef()) {
      composeReference("ref", element.getRef());
    }
  }

  protected void composeDocumentReference(String name, DocumentReference element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeDocumentReferenceInner(element);
    }
  }

  protected void composeDocumentReferenceInner(DocumentReference element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasMasterIdentifier()) {
      composeIdentifier("masterIdentifier", element.getMasterIdentifier());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasClass_()) {
      composeCodeableConcept("class", element.getClass_());
    }
    if (element.hasAuthor()) {
      openArray("author");
      for (Reference e : element.getAuthor())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasCustodian()) {
      composeReference("custodian", element.getCustodian());
    }
    if (element.hasAuthenticator()) {
      composeReference("authenticator", element.getAuthenticator());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasIndexedElement()) {
      composeInstantCore("indexed", element.getIndexedElement(), false);
      composeInstantExtras("indexed", element.getIndexedElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.DocumentReferenceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.DocumentReferenceStatusEnumFactory(), false);
    }
    if (element.hasDocStatus()) {
      composeCodeableConcept("docStatus", element.getDocStatus());
    }
    if (element.hasRelatesTo()) {
      openArray("relatesTo");
      for (DocumentReference.DocumentReferenceRelatesToComponent e : element.getRelatesTo())
        composeDocumentReferenceDocumentReferenceRelatesToComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasSecurityLabel()) {
      openArray("securityLabel");
      for (CodeableConcept e : element.getSecurityLabel())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasContent()) {
      openArray("content");
      for (DocumentReference.DocumentReferenceContentComponent e : element.getContent())
        composeDocumentReferenceDocumentReferenceContentComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasContext()) {
      composeDocumentReferenceDocumentReferenceContextComponent("context", element.getContext());
    }
  }

  protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(String name,
      DocumentReference.DocumentReferenceRelatesToComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentReferenceDocumentReferenceRelatesToComponentInner(element);
      close();
    }
  }

  protected void composeDocumentReferenceDocumentReferenceRelatesToComponentInner(
      DocumentReference.DocumentReferenceRelatesToComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(),
          new DocumentReference.DocumentRelationshipTypeEnumFactory(), false);
      composeEnumerationExtras("code", element.getCodeElement(),
          new DocumentReference.DocumentRelationshipTypeEnumFactory(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
  }

  protected void composeDocumentReferenceDocumentReferenceContentComponent(String name,
      DocumentReference.DocumentReferenceContentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentReferenceDocumentReferenceContentComponentInner(element);
      close();
    }
  }

  protected void composeDocumentReferenceDocumentReferenceContentComponentInner(
      DocumentReference.DocumentReferenceContentComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasAttachment()) {
      composeAttachment("attachment", element.getAttachment());
    }
    if (element.hasFormat()) {
      openArray("format");
      for (Coding e : element.getFormat())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDocumentReferenceDocumentReferenceContextComponent(String name,
      DocumentReference.DocumentReferenceContextComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentReferenceDocumentReferenceContextComponentInner(element);
      close();
    }
  }

  protected void composeDocumentReferenceDocumentReferenceContextComponentInner(
      DocumentReference.DocumentReferenceContextComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasEvent()) {
      openArray("event");
      for (CodeableConcept e : element.getEvent())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasFacilityType()) {
      composeCodeableConcept("facilityType", element.getFacilityType());
    }
    if (element.hasPracticeSetting()) {
      composeCodeableConcept("practiceSetting", element.getPracticeSetting());
    }
    if (element.hasSourcePatientInfo()) {
      composeReference("sourcePatientInfo", element.getSourcePatientInfo());
    }
    if (element.hasRelated()) {
      openArray("related");
      for (DocumentReference.DocumentReferenceContextRelatedComponent e : element.getRelated())
        composeDocumentReferenceDocumentReferenceContextRelatedComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(String name,
      DocumentReference.DocumentReferenceContextRelatedComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeDocumentReferenceDocumentReferenceContextRelatedComponentInner(element);
      close();
    }
  }

  protected void composeDocumentReferenceDocumentReferenceContextRelatedComponentInner(
      DocumentReference.DocumentReferenceContextRelatedComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasRef()) {
      composeReference("ref", element.getRef());
    }
  }

  protected void composeEligibilityRequest(String name, EligibilityRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEligibilityRequestInner(element);
    }
  }

  protected void composeEligibilityRequestInner(EligibilityRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
  }

  protected void composeEligibilityResponse(String name, EligibilityResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEligibilityResponseInner(element);
    }
  }

  protected void composeEligibilityResponseInner(EligibilityResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
  }

  protected void composeEncounter(String name, Encounter element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEncounterInner(element);
    }
  }

  protected void composeEncounterInner(Encounter element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory(), false);
    }
    if (element.hasStatusHistory()) {
      openArray("statusHistory");
      for (Encounter.EncounterStatusHistoryComponent e : element.getStatusHistory())
        composeEncounterEncounterStatusHistoryComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasClass_Element()) {
      composeEnumerationCore("class", element.getClass_Element(), new Encounter.EncounterClassEnumFactory(), false);
      composeEnumerationExtras("class", element.getClass_Element(), new Encounter.EncounterClassEnumFactory(), false);
    }
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPriority()) {
      composeCodeableConcept("priority", element.getPriority());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasEpisodeOfCare()) {
      openArray("episodeOfCare");
      for (Reference e : element.getEpisodeOfCare())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasIncomingReferral()) {
      openArray("incomingReferral");
      for (Reference e : element.getIncomingReferral())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasParticipant()) {
      openArray("participant");
      for (Encounter.EncounterParticipantComponent e : element.getParticipant())
        composeEncounterEncounterParticipantComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasAppointment()) {
      composeReference("appointment", element.getAppointment());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasLength()) {
      composeDuration("length", element.getLength());
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasIndication()) {
      openArray("indication");
      for (Reference e : element.getIndication())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasHospitalization()) {
      composeEncounterEncounterHospitalizationComponent("hospitalization", element.getHospitalization());
    }
    if (element.hasLocation()) {
      openArray("location");
      for (Encounter.EncounterLocationComponent e : element.getLocation())
        composeEncounterEncounterLocationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasServiceProvider()) {
      composeReference("serviceProvider", element.getServiceProvider());
    }
    if (element.hasPartOf()) {
      composeReference("partOf", element.getPartOf());
    }
  }

  protected void composeEncounterEncounterStatusHistoryComponent(String name,
      Encounter.EncounterStatusHistoryComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeEncounterEncounterStatusHistoryComponentInner(element);
      close();
    }
  }

  protected void composeEncounterEncounterStatusHistoryComponentInner(Encounter.EncounterStatusHistoryComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeEncounterEncounterParticipantComponent(String name,
      Encounter.EncounterParticipantComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeEncounterEncounterParticipantComponentInner(element);
      close();
    }
  }

  protected void composeEncounterEncounterParticipantComponentInner(Encounter.EncounterParticipantComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasIndividual()) {
      composeReference("individual", element.getIndividual());
    }
  }

  protected void composeEncounterEncounterHospitalizationComponent(String name,
      Encounter.EncounterHospitalizationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeEncounterEncounterHospitalizationComponentInner(element);
      close();
    }
  }

  protected void composeEncounterEncounterHospitalizationComponentInner(
      Encounter.EncounterHospitalizationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasPreAdmissionIdentifier()) {
      composeIdentifier("preAdmissionIdentifier", element.getPreAdmissionIdentifier());
    }
    if (element.hasOrigin()) {
      composeReference("origin", element.getOrigin());
    }
    if (element.hasAdmitSource()) {
      composeCodeableConcept("admitSource", element.getAdmitSource());
    }
    if (element.hasAdmittingDiagnosis()) {
      openArray("admittingDiagnosis");
      for (Reference e : element.getAdmittingDiagnosis())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasReAdmission()) {
      composeCodeableConcept("reAdmission", element.getReAdmission());
    }
    if (element.hasDietPreference()) {
      openArray("dietPreference");
      for (CodeableConcept e : element.getDietPreference())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSpecialCourtesy()) {
      openArray("specialCourtesy");
      for (CodeableConcept e : element.getSpecialCourtesy())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSpecialArrangement()) {
      openArray("specialArrangement");
      for (CodeableConcept e : element.getSpecialArrangement())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDestination()) {
      composeReference("destination", element.getDestination());
    }
    if (element.hasDischargeDisposition()) {
      composeCodeableConcept("dischargeDisposition", element.getDischargeDisposition());
    }
    if (element.hasDischargeDiagnosis()) {
      openArray("dischargeDiagnosis");
      for (Reference e : element.getDischargeDiagnosis())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeEncounterEncounterLocationComponent(String name, Encounter.EncounterLocationComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeEncounterEncounterLocationComponentInner(element);
      close();
    }
  }

  protected void composeEncounterEncounterLocationComponentInner(Encounter.EncounterLocationComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Encounter.EncounterLocationStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Encounter.EncounterLocationStatusEnumFactory(),
          false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeEnrollmentRequest(String name, EnrollmentRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEnrollmentRequestInner(element);
    }
  }

  protected void composeEnrollmentRequestInner(EnrollmentRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasCoverage()) {
      composeReference("coverage", element.getCoverage());
    }
    if (element.hasRelationship()) {
      composeCoding("relationship", element.getRelationship());
    }
  }

  protected void composeEnrollmentResponse(String name, EnrollmentResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEnrollmentResponseInner(element);
    }
  }

  protected void composeEnrollmentResponseInner(EnrollmentResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
  }

  protected void composeEpisodeOfCare(String name, EpisodeOfCare element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeEpisodeOfCareInner(element);
    }
  }

  protected void composeEpisodeOfCareInner(EpisodeOfCare element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory(),
          false);
    }
    if (element.hasStatusHistory()) {
      openArray("statusHistory");
      for (EpisodeOfCare.EpisodeOfCareStatusHistoryComponent e : element.getStatusHistory())
        composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasCondition()) {
      openArray("condition");
      for (Reference e : element.getCondition())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasManagingOrganization()) {
      composeReference("managingOrganization", element.getManagingOrganization());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasReferralRequest()) {
      openArray("referralRequest");
      for (Reference e : element.getReferralRequest())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasCareManager()) {
      composeReference("careManager", element.getCareManager());
    }
    if (element.hasCareTeam()) {
      openArray("careTeam");
      for (EpisodeOfCare.EpisodeOfCareCareTeamComponent e : element.getCareTeam())
        composeEpisodeOfCareEpisodeOfCareCareTeamComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(String name,
      EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeEpisodeOfCareEpisodeOfCareStatusHistoryComponentInner(element);
      close();
    }
  }

  protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponentInner(
      EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory(),
          false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeEpisodeOfCareEpisodeOfCareCareTeamComponent(String name,
      EpisodeOfCare.EpisodeOfCareCareTeamComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeEpisodeOfCareEpisodeOfCareCareTeamComponentInner(element);
      close();
    }
  }

  protected void composeEpisodeOfCareEpisodeOfCareCareTeamComponentInner(
      EpisodeOfCare.EpisodeOfCareCareTeamComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasRole()) {
      openArray("role");
      for (CodeableConcept e : element.getRole())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasMember()) {
      composeReference("member", element.getMember());
    }
  }

  protected void composeExplanationOfBenefit(String name, ExplanationOfBenefit element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeExplanationOfBenefitInner(element);
    }
  }

  protected void composeExplanationOfBenefitInner(ExplanationOfBenefit element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
  }

  protected void composeFamilyMemberHistory(String name, FamilyMemberHistory element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeFamilyMemberHistoryInner(element);
    }
  }

  protected void composeFamilyMemberHistoryInner(FamilyMemberHistory element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new FamilyMemberHistory.FamilyHistoryStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new FamilyMemberHistory.FamilyHistoryStatusEnumFactory(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasRelationship()) {
      composeCodeableConcept("relationship", element.getRelationship());
    }
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasBorn()) {
      composeType("born", element.getBorn());
    }
    if (element.hasAge()) {
      composeType("age", element.getAge());
    }
    if (element.hasDeceased()) {
      composeType("deceased", element.getDeceased());
    }
    if (element.hasNote()) {
      composeAnnotation("note", element.getNote());
    }
    if (element.hasCondition()) {
      openArray("condition");
      for (FamilyMemberHistory.FamilyMemberHistoryConditionComponent e : element.getCondition())
        composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(String name,
      FamilyMemberHistory.FamilyMemberHistoryConditionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeFamilyMemberHistoryFamilyMemberHistoryConditionComponentInner(element);
      close();
    }
  }

  protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponentInner(
      FamilyMemberHistory.FamilyMemberHistoryConditionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasOutcome()) {
      composeCodeableConcept("outcome", element.getOutcome());
    }
    if (element.hasOnset()) {
      composeType("onset", element.getOnset());
    }
    if (element.hasNote()) {
      composeAnnotation("note", element.getNote());
    }
  }

  protected void composeFlag(String name, Flag element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeFlagInner(element);
    }
  }

  protected void composeFlagInner(Flag element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Flag.FlagStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Flag.FlagStatusEnumFactory(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
  }

  protected void composeGoal(String name, Goal element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeGoalInner(element);
    }
  }

  protected void composeGoalInner(Goal element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasStart()) {
      composeType("start", element.getStart());
    }
    if (element.hasTarget()) {
      composeType("target", element.getTarget());
    }
    if (element.hasCategory()) {
      openArray("category");
      for (CodeableConcept e : element.getCategory())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Goal.GoalStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Goal.GoalStatusEnumFactory(), false);
    }
    if (element.hasStatusDateElement()) {
      composeDateCore("statusDate", element.getStatusDateElement(), false);
      composeDateExtras("statusDate", element.getStatusDateElement(), false);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept("statusReason", element.getStatusReason());
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasPriority()) {
      composeCodeableConcept("priority", element.getPriority());
    }
    if (element.hasAddresses()) {
      openArray("addresses");
      for (Reference e : element.getAddresses())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasNote()) {
      openArray("note");
      for (Annotation e : element.getNote())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasOutcome()) {
      openArray("outcome");
      for (Goal.GoalOutcomeComponent e : element.getOutcome())
        composeGoalGoalOutcomeComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeGoalGoalOutcomeComponent(String name, Goal.GoalOutcomeComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeGoalGoalOutcomeComponentInner(element);
      close();
    }
  }

  protected void composeGoalGoalOutcomeComponentInner(Goal.GoalOutcomeComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasResult()) {
      composeType("result", element.getResult());
    }
  }

  protected void composeGroup(String name, Group element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeGroupInner(element);
    }
  }

  protected void composeGroupInner(Group element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Group.GroupTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Group.GroupTypeEnumFactory(), false);
    }
    if (element.hasActualElement()) {
      composeBooleanCore("actual", element.getActualElement(), false);
      composeBooleanExtras("actual", element.getActualElement(), false);
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasQuantityElement()) {
      composeUnsignedIntCore("quantity", element.getQuantityElement(), false);
      composeUnsignedIntExtras("quantity", element.getQuantityElement(), false);
    }
    if (element.hasCharacteristic()) {
      openArray("characteristic");
      for (Group.GroupCharacteristicComponent e : element.getCharacteristic())
        composeGroupGroupCharacteristicComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMember()) {
      openArray("member");
      for (Group.GroupMemberComponent e : element.getMember())
        composeGroupGroupMemberComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeGroupGroupCharacteristicComponent(String name, Group.GroupCharacteristicComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeGroupGroupCharacteristicComponentInner(element);
      close();
    }
  }

  protected void composeGroupGroupCharacteristicComponentInner(Group.GroupCharacteristicComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
    if (element.hasExcludeElement()) {
      composeBooleanCore("exclude", element.getExcludeElement(), false);
      composeBooleanExtras("exclude", element.getExcludeElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeGroupGroupMemberComponent(String name, Group.GroupMemberComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeGroupGroupMemberComponentInner(element);
      close();
    }
  }

  protected void composeGroupGroupMemberComponentInner(Group.GroupMemberComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasEntity()) {
      composeReference("entity", element.getEntity());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasInactiveElement()) {
      composeBooleanCore("inactive", element.getInactiveElement(), false);
      composeBooleanExtras("inactive", element.getInactiveElement(), false);
    }
  }

  protected void composeHealthcareService(String name, HealthcareService element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeHealthcareServiceInner(element);
    }
  }

  protected void composeHealthcareServiceInner(HealthcareService element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasProvidedBy()) {
      composeReference("providedBy", element.getProvidedBy());
    }
    if (element.hasServiceCategory()) {
      composeCodeableConcept("serviceCategory", element.getServiceCategory());
    }
    if (element.hasServiceType()) {
      openArray("serviceType");
      for (HealthcareService.ServiceTypeComponent e : element.getServiceType())
        composeHealthcareServiceServiceTypeComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasServiceNameElement()) {
      composeStringCore("serviceName", element.getServiceNameElement(), false);
      composeStringExtras("serviceName", element.getServiceNameElement(), false);
    }
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
    if (element.hasExtraDetailsElement()) {
      composeStringCore("extraDetails", element.getExtraDetailsElement(), false);
      composeStringExtras("extraDetails", element.getExtraDetailsElement(), false);
    }
    if (element.hasPhoto()) {
      composeAttachment("photo", element.getPhoto());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasCoverageArea()) {
      openArray("coverageArea");
      for (Reference e : element.getCoverageArea())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasServiceProvisionCode()) {
      openArray("serviceProvisionCode");
      for (CodeableConcept e : element.getServiceProvisionCode())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasEligibility()) {
      composeCodeableConcept("eligibility", element.getEligibility());
    }
    if (element.hasEligibilityNoteElement()) {
      composeStringCore("eligibilityNote", element.getEligibilityNoteElement(), false);
      composeStringExtras("eligibilityNote", element.getEligibilityNoteElement(), false);
    }
    if (element.hasProgramName()) {
      openArray("programName");
      for (StringType e : element.getProgramName())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getProgramName())) {
        openArray("_programName");
        for (StringType e : element.getProgramName())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasCharacteristic()) {
      openArray("characteristic");
      for (CodeableConcept e : element.getCharacteristic())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReferralMethod()) {
      openArray("referralMethod");
      for (CodeableConcept e : element.getReferralMethod())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPublicKeyElement()) {
      composeStringCore("publicKey", element.getPublicKeyElement(), false);
      composeStringExtras("publicKey", element.getPublicKeyElement(), false);
    }
    if (element.hasAppointmentRequiredElement()) {
      composeBooleanCore("appointmentRequired", element.getAppointmentRequiredElement(), false);
      composeBooleanExtras("appointmentRequired", element.getAppointmentRequiredElement(), false);
    }
    if (element.hasAvailableTime()) {
      openArray("availableTime");
      for (HealthcareService.HealthcareServiceAvailableTimeComponent e : element.getAvailableTime())
        composeHealthcareServiceHealthcareServiceAvailableTimeComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasNotAvailable()) {
      openArray("notAvailable");
      for (HealthcareService.HealthcareServiceNotAvailableComponent e : element.getNotAvailable())
        composeHealthcareServiceHealthcareServiceNotAvailableComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasAvailabilityExceptionsElement()) {
      composeStringCore("availabilityExceptions", element.getAvailabilityExceptionsElement(), false);
      composeStringExtras("availabilityExceptions", element.getAvailabilityExceptionsElement(), false);
    }
  }

  protected void composeHealthcareServiceServiceTypeComponent(String name,
      HealthcareService.ServiceTypeComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeHealthcareServiceServiceTypeComponentInner(element);
      close();
    }
  }

  protected void composeHealthcareServiceServiceTypeComponentInner(HealthcareService.ServiceTypeComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSpecialty()) {
      openArray("specialty");
      for (CodeableConcept e : element.getSpecialty())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
  }

  protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(String name,
      HealthcareService.HealthcareServiceAvailableTimeComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeHealthcareServiceHealthcareServiceAvailableTimeComponentInner(element);
      close();
    }
  }

  protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponentInner(
      HealthcareService.HealthcareServiceAvailableTimeComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDaysOfWeek()) {
      openArray("daysOfWeek");
      for (Enumeration<HealthcareService.DaysOfWeek> e : element.getDaysOfWeek())
        composeEnumerationCore(null, e, new HealthcareService.DaysOfWeekEnumFactory(), true);
      closeArray();
      if (anyHasExtras(element.getDaysOfWeek())) {
        openArray("_daysOfWeek");
        for (Enumeration<HealthcareService.DaysOfWeek> e : element.getDaysOfWeek())
          composeEnumerationExtras(null, e, new HealthcareService.DaysOfWeekEnumFactory(), true);
        closeArray();
      }
    }
    ;
    if (element.hasAllDayElement()) {
      composeBooleanCore("allDay", element.getAllDayElement(), false);
      composeBooleanExtras("allDay", element.getAllDayElement(), false);
    }
    if (element.hasAvailableStartTimeElement()) {
      composeTimeCore("availableStartTime", element.getAvailableStartTimeElement(), false);
      composeTimeExtras("availableStartTime", element.getAvailableStartTimeElement(), false);
    }
    if (element.hasAvailableEndTimeElement()) {
      composeTimeCore("availableEndTime", element.getAvailableEndTimeElement(), false);
      composeTimeExtras("availableEndTime", element.getAvailableEndTimeElement(), false);
    }
  }

  protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(String name,
      HealthcareService.HealthcareServiceNotAvailableComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeHealthcareServiceHealthcareServiceNotAvailableComponentInner(element);
      close();
    }
  }

  protected void composeHealthcareServiceHealthcareServiceNotAvailableComponentInner(
      HealthcareService.HealthcareServiceNotAvailableComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasDuring()) {
      composePeriod("during", element.getDuring());
    }
  }

  protected void composeImagingObjectSelection(String name, ImagingObjectSelection element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeImagingObjectSelectionInner(element);
    }
  }

  protected void composeImagingObjectSelectionInner(ImagingObjectSelection element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasTitle()) {
      composeCodeableConcept("title", element.getTitle());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasAuthoringTimeElement()) {
      composeDateTimeCore("authoringTime", element.getAuthoringTimeElement(), false);
      composeDateTimeExtras("authoringTime", element.getAuthoringTimeElement(), false);
    }
    if (element.hasStudy()) {
      openArray("study");
      for (ImagingObjectSelection.StudyComponent e : element.getStudy())
        composeImagingObjectSelectionStudyComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingObjectSelectionStudyComponent(String name, ImagingObjectSelection.StudyComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeImagingObjectSelectionStudyComponentInner(element);
      close();
    }
  }

  protected void composeImagingObjectSelectionStudyComponentInner(ImagingObjectSelection.StudyComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasImagingStudy()) {
      composeReference("imagingStudy", element.getImagingStudy());
    }
    if (element.hasSeries()) {
      openArray("series");
      for (ImagingObjectSelection.SeriesComponent e : element.getSeries())
        composeImagingObjectSelectionSeriesComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingObjectSelectionSeriesComponent(String name,
      ImagingObjectSelection.SeriesComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImagingObjectSelectionSeriesComponentInner(element);
      close();
    }
  }

  protected void composeImagingObjectSelectionSeriesComponentInner(ImagingObjectSelection.SeriesComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasInstance()) {
      openArray("instance");
      for (ImagingObjectSelection.InstanceComponent e : element.getInstance())
        composeImagingObjectSelectionInstanceComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingObjectSelectionInstanceComponent(String name,
      ImagingObjectSelection.InstanceComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImagingObjectSelectionInstanceComponentInner(element);
      close();
    }
  }

  protected void composeImagingObjectSelectionInstanceComponentInner(ImagingObjectSelection.InstanceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSopClassElement()) {
      composeOidCore("sopClass", element.getSopClassElement(), false);
      composeOidExtras("sopClass", element.getSopClassElement(), false);
    }
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasFrames()) {
      openArray("frames");
      for (ImagingObjectSelection.FramesComponent e : element.getFrames())
        composeImagingObjectSelectionFramesComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingObjectSelectionFramesComponent(String name,
      ImagingObjectSelection.FramesComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImagingObjectSelectionFramesComponentInner(element);
      close();
    }
  }

  protected void composeImagingObjectSelectionFramesComponentInner(ImagingObjectSelection.FramesComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasFrameNumbers()) {
      openArray("frameNumbers");
      for (UnsignedIntType e : element.getFrameNumbers())
        composeUnsignedIntCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getFrameNumbers())) {
        openArray("_frameNumbers");
        for (UnsignedIntType e : element.getFrameNumbers())
          composeUnsignedIntExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
  }

  protected void composeImagingStudy(String name, ImagingStudy element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeImagingStudyInner(element);
    }
  }

  protected void composeImagingStudyInner(ImagingStudy element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasStartedElement()) {
      composeDateTimeCore("started", element.getStartedElement(), false);
      composeDateTimeExtras("started", element.getStartedElement(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasAccession()) {
      composeIdentifier("accession", element.getAccession());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasOrder()) {
      openArray("order");
      for (Reference e : element.getOrder())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasModalityList()) {
      openArray("modalityList");
      for (Coding e : element.getModalityList())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasReferrer()) {
      composeReference("referrer", element.getReferrer());
    }
    if (element.hasAvailabilityElement()) {
      composeEnumerationCore("availability", element.getAvailabilityElement(),
          new ImagingStudy.InstanceAvailabilityEnumFactory(), false);
      composeEnumerationExtras("availability", element.getAvailabilityElement(),
          new ImagingStudy.InstanceAvailabilityEnumFactory(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasNumberOfSeriesElement()) {
      composeUnsignedIntCore("numberOfSeries", element.getNumberOfSeriesElement(), false);
      composeUnsignedIntExtras("numberOfSeries", element.getNumberOfSeriesElement(), false);
    }
    if (element.hasNumberOfInstancesElement()) {
      composeUnsignedIntCore("numberOfInstances", element.getNumberOfInstancesElement(), false);
      composeUnsignedIntExtras("numberOfInstances", element.getNumberOfInstancesElement(), false);
    }
    if (element.hasProcedure()) {
      openArray("procedure");
      for (Reference e : element.getProcedure())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasInterpreter()) {
      composeReference("interpreter", element.getInterpreter());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasSeries()) {
      openArray("series");
      for (ImagingStudy.ImagingStudySeriesComponent e : element.getSeries())
        composeImagingStudyImagingStudySeriesComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingStudyImagingStudySeriesComponent(String name,
      ImagingStudy.ImagingStudySeriesComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImagingStudyImagingStudySeriesComponentInner(element);
      close();
    }
  }

  protected void composeImagingStudyImagingStudySeriesComponentInner(ImagingStudy.ImagingStudySeriesComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNumberElement()) {
      composeUnsignedIntCore("number", element.getNumberElement(), false);
      composeUnsignedIntExtras("number", element.getNumberElement(), false);
    }
    if (element.hasModality()) {
      composeCoding("modality", element.getModality());
    }
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasNumberOfInstancesElement()) {
      composeUnsignedIntCore("numberOfInstances", element.getNumberOfInstancesElement(), false);
      composeUnsignedIntExtras("numberOfInstances", element.getNumberOfInstancesElement(), false);
    }
    if (element.hasAvailabilityElement()) {
      composeEnumerationCore("availability", element.getAvailabilityElement(),
          new ImagingStudy.InstanceAvailabilityEnumFactory(), false);
      composeEnumerationExtras("availability", element.getAvailabilityElement(),
          new ImagingStudy.InstanceAvailabilityEnumFactory(), false);
    }
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasBodySite()) {
      composeCoding("bodySite", element.getBodySite());
    }
    if (element.hasLaterality()) {
      composeCoding("laterality", element.getLaterality());
    }
    if (element.hasStartedElement()) {
      composeDateTimeCore("started", element.getStartedElement(), false);
      composeDateTimeExtras("started", element.getStartedElement(), false);
    }
    if (element.hasInstance()) {
      openArray("instance");
      for (ImagingStudy.ImagingStudySeriesInstanceComponent e : element.getInstance())
        composeImagingStudyImagingStudySeriesInstanceComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImagingStudyImagingStudySeriesInstanceComponent(String name,
      ImagingStudy.ImagingStudySeriesInstanceComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImagingStudyImagingStudySeriesInstanceComponentInner(element);
      close();
    }
  }

  protected void composeImagingStudyImagingStudySeriesInstanceComponentInner(
      ImagingStudy.ImagingStudySeriesInstanceComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNumberElement()) {
      composeUnsignedIntCore("number", element.getNumberElement(), false);
      composeUnsignedIntExtras("number", element.getNumberElement(), false);
    }
    if (element.hasUidElement()) {
      composeOidCore("uid", element.getUidElement(), false);
      composeOidExtras("uid", element.getUidElement(), false);
    }
    if (element.hasSopClassElement()) {
      composeOidCore("sopClass", element.getSopClassElement(), false);
      composeOidExtras("sopClass", element.getSopClassElement(), false);
    }
    if (element.hasTypeElement()) {
      composeStringCore("type", element.getTypeElement(), false);
      composeStringExtras("type", element.getTypeElement(), false);
    }
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasContent()) {
      openArray("content");
      for (Attachment e : element.getContent())
        composeAttachment(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImmunization(String name, Immunization element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeImmunizationInner(element);
    }
  }

  protected void composeImmunizationInner(Immunization element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeCodeCore("status", element.getStatusElement(), false);
      composeCodeExtras("status", element.getStatusElement(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasVaccineCode()) {
      composeCodeableConcept("vaccineCode", element.getVaccineCode());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasWasNotGivenElement()) {
      composeBooleanCore("wasNotGiven", element.getWasNotGivenElement(), false);
      composeBooleanExtras("wasNotGiven", element.getWasNotGivenElement(), false);
    }
    if (element.hasReportedElement()) {
      composeBooleanCore("reported", element.getReportedElement(), false);
      composeBooleanExtras("reported", element.getReportedElement(), false);
    }
    if (element.hasPerformer()) {
      composeReference("performer", element.getPerformer());
    }
    if (element.hasRequester()) {
      composeReference("requester", element.getRequester());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasManufacturer()) {
      composeReference("manufacturer", element.getManufacturer());
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasLotNumberElement()) {
      composeStringCore("lotNumber", element.getLotNumberElement(), false);
      composeStringExtras("lotNumber", element.getLotNumberElement(), false);
    }
    if (element.hasExpirationDateElement()) {
      composeDateCore("expirationDate", element.getExpirationDateElement(), false);
      composeDateExtras("expirationDate", element.getExpirationDateElement(), false);
    }
    if (element.hasSite()) {
      composeCodeableConcept("site", element.getSite());
    }
    if (element.hasRoute()) {
      composeCodeableConcept("route", element.getRoute());
    }
    if (element.hasDoseQuantity()) {
      composeSimpleQuantity("doseQuantity", element.getDoseQuantity());
    }
    if (element.hasNote()) {
      openArray("note");
      for (Annotation e : element.getNote())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasExplanation()) {
      composeImmunizationImmunizationExplanationComponent("explanation", element.getExplanation());
    }
    if (element.hasReaction()) {
      openArray("reaction");
      for (Immunization.ImmunizationReactionComponent e : element.getReaction())
        composeImmunizationImmunizationReactionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasVaccinationProtocol()) {
      openArray("vaccinationProtocol");
      for (Immunization.ImmunizationVaccinationProtocolComponent e : element.getVaccinationProtocol())
        composeImmunizationImmunizationVaccinationProtocolComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImmunizationImmunizationExplanationComponent(String name,
      Immunization.ImmunizationExplanationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationImmunizationExplanationComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationImmunizationExplanationComponentInner(
      Immunization.ImmunizationExplanationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReasonNotGiven()) {
      openArray("reasonNotGiven");
      for (CodeableConcept e : element.getReasonNotGiven())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImmunizationImmunizationReactionComponent(String name,
      Immunization.ImmunizationReactionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationImmunizationReactionComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationImmunizationReactionComponentInner(
      Immunization.ImmunizationReactionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDetail()) {
      composeReference("detail", element.getDetail());
    }
    if (element.hasReportedElement()) {
      composeBooleanCore("reported", element.getReportedElement(), false);
      composeBooleanExtras("reported", element.getReportedElement(), false);
    }
  }

  protected void composeImmunizationImmunizationVaccinationProtocolComponent(String name,
      Immunization.ImmunizationVaccinationProtocolComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationImmunizationVaccinationProtocolComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationImmunizationVaccinationProtocolComponentInner(
      Immunization.ImmunizationVaccinationProtocolComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDoseSequenceElement()) {
      composePositiveIntCore("doseSequence", element.getDoseSequenceElement(), false);
      composePositiveIntExtras("doseSequence", element.getDoseSequenceElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAuthority()) {
      composeReference("authority", element.getAuthority());
    }
    if (element.hasSeriesElement()) {
      composeStringCore("series", element.getSeriesElement(), false);
      composeStringExtras("series", element.getSeriesElement(), false);
    }
    if (element.hasSeriesDosesElement()) {
      composePositiveIntCore("seriesDoses", element.getSeriesDosesElement(), false);
      composePositiveIntExtras("seriesDoses", element.getSeriesDosesElement(), false);
    }
    if (element.hasTargetDisease()) {
      openArray("targetDisease");
      for (CodeableConcept e : element.getTargetDisease())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasDoseStatus()) {
      composeCodeableConcept("doseStatus", element.getDoseStatus());
    }
    if (element.hasDoseStatusReason()) {
      composeCodeableConcept("doseStatusReason", element.getDoseStatusReason());
    }
  }

  protected void composeImmunizationRecommendation(String name, ImmunizationRecommendation element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeImmunizationRecommendationInner(element);
    }
  }

  protected void composeImmunizationRecommendationInner(ImmunizationRecommendation element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasRecommendation()) {
      openArray("recommendation");
      for (ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent e : element.getRecommendation())
        composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(String name,
      ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationRecommendationImmunizationRecommendationRecommendationComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponentInner(
      ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasVaccineCode()) {
      composeCodeableConcept("vaccineCode", element.getVaccineCode());
    }
    if (element.hasDoseNumberElement()) {
      composePositiveIntCore("doseNumber", element.getDoseNumberElement(), false);
      composePositiveIntExtras("doseNumber", element.getDoseNumberElement(), false);
    }
    if (element.hasForecastStatus()) {
      composeCodeableConcept("forecastStatus", element.getForecastStatus());
    }
    if (element.hasDateCriterion()) {
      openArray("dateCriterion");
      for (ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent e : element
          .getDateCriterion())
        composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasProtocol()) {
      composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent("protocol",
          element.getProtocol());
    }
    if (element.hasSupportingImmunization()) {
      openArray("supportingImmunization");
      for (Reference e : element.getSupportingImmunization())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasSupportingPatientInformation()) {
      openArray("supportingPatientInformation");
      for (Reference e : element.getSupportingPatientInformation())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(
      String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentInner(
      ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasValueElement()) {
      composeDateTimeCore("value", element.getValueElement(), false);
      composeDateTimeExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(String name,
      ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentInner(element);
      close();
    }
  }

  protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentInner(
      ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasDoseSequenceElement()) {
      composeIntegerCore("doseSequence", element.getDoseSequenceElement(), false);
      composeIntegerExtras("doseSequence", element.getDoseSequenceElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAuthority()) {
      composeReference("authority", element.getAuthority());
    }
    if (element.hasSeriesElement()) {
      composeStringCore("series", element.getSeriesElement(), false);
      composeStringExtras("series", element.getSeriesElement(), false);
    }
  }

  protected void composeImplementationGuide(String name, ImplementationGuide element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeImplementationGuideInner(element);
    }
  }

  protected void composeImplementationGuideInner(ImplementationGuide element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (ImplementationGuide.ImplementationGuideContactComponent e : element.getContact())
        composeImplementationGuideImplementationGuideContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasFhirVersionElement()) {
      composeIdCore("fhirVersion", element.getFhirVersionElement(), false);
      composeIdExtras("fhirVersion", element.getFhirVersionElement(), false);
    }
    if (element.hasDependency()) {
      openArray("dependency");
      for (ImplementationGuide.ImplementationGuideDependencyComponent e : element.getDependency())
        composeImplementationGuideImplementationGuideDependencyComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasPackage()) {
      openArray("package");
      for (ImplementationGuide.ImplementationGuidePackageComponent e : element.getPackage())
        composeImplementationGuideImplementationGuidePackageComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasGlobal()) {
      openArray("global");
      for (ImplementationGuide.ImplementationGuideGlobalComponent e : element.getGlobal())
        composeImplementationGuideImplementationGuideGlobalComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasBinary()) {
      openArray("binary");
      for (UriType e : element.getBinary())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getBinary())) {
        openArray("_binary");
        for (UriType e : element.getBinary())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPage()) {
      composeImplementationGuideImplementationGuidePageComponent("page", element.getPage());
    }
  }

  protected void composeImplementationGuideImplementationGuideContactComponent(String name,
      ImplementationGuide.ImplementationGuideContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuideContactComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuideContactComponentInner(
      ImplementationGuide.ImplementationGuideContactComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImplementationGuideImplementationGuideDependencyComponent(String name,
      ImplementationGuide.ImplementationGuideDependencyComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuideDependencyComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuideDependencyComponentInner(
      ImplementationGuide.ImplementationGuideDependencyComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new ImplementationGuide.GuideDependencyTypeEnumFactory(),
          false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new ImplementationGuide.GuideDependencyTypeEnumFactory(), false);
    }
    if (element.hasUriElement()) {
      composeUriCore("uri", element.getUriElement(), false);
      composeUriExtras("uri", element.getUriElement(), false);
    }
  }

  protected void composeImplementationGuideImplementationGuidePackageComponent(String name,
      ImplementationGuide.ImplementationGuidePackageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuidePackageComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuidePackageComponentInner(
      ImplementationGuide.ImplementationGuidePackageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasResource()) {
      openArray("resource");
      for (ImplementationGuide.ImplementationGuidePackageResourceComponent e : element.getResource())
        composeImplementationGuideImplementationGuidePackageResourceComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeImplementationGuideImplementationGuidePackageResourceComponent(String name,
      ImplementationGuide.ImplementationGuidePackageResourceComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuidePackageResourceComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuidePackageResourceComponentInner(
      ImplementationGuide.ImplementationGuidePackageResourceComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasPurposeElement()) {
      composeEnumerationCore("purpose", element.getPurposeElement(),
          new ImplementationGuide.GuideResourcePurposeEnumFactory(), false);
      composeEnumerationExtras("purpose", element.getPurposeElement(),
          new ImplementationGuide.GuideResourcePurposeEnumFactory(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAcronymElement()) {
      composeStringCore("acronym", element.getAcronymElement(), false);
      composeStringExtras("acronym", element.getAcronymElement(), false);
    }
    if (element.hasSource()) {
      composeType("source", element.getSource());
    }
    if (element.hasExampleFor()) {
      composeReference("exampleFor", element.getExampleFor());
    }
  }

  protected void composeImplementationGuideImplementationGuideGlobalComponent(String name,
      ImplementationGuide.ImplementationGuideGlobalComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuideGlobalComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuideGlobalComponentInner(
      ImplementationGuide.ImplementationGuideGlobalComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeCodeCore("type", element.getTypeElement(), false);
      composeCodeExtras("type", element.getTypeElement(), false);
    }
    if (element.hasProfile()) {
      composeReference("profile", element.getProfile());
    }
  }

  protected void composeImplementationGuideImplementationGuidePageComponent(String name,
      ImplementationGuide.ImplementationGuidePageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeImplementationGuideImplementationGuidePageComponentInner(element);
      close();
    }
  }

  protected void composeImplementationGuideImplementationGuidePageComponentInner(
      ImplementationGuide.ImplementationGuidePageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSourceElement()) {
      composeUriCore("source", element.getSourceElement(), false);
      composeUriExtras("source", element.getSourceElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasKindElement()) {
      composeEnumerationCore("kind", element.getKindElement(), new ImplementationGuide.GuidePageKindEnumFactory(),
          false);
      composeEnumerationExtras("kind", element.getKindElement(), new ImplementationGuide.GuidePageKindEnumFactory(),
          false);
    }
    if (element.hasType()) {
      openArray("type");
      for (CodeType e : element.getType())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getType())) {
        openArray("_type");
        for (CodeType e : element.getType())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPackage()) {
      openArray("package");
      for (StringType e : element.getPackage())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPackage())) {
        openArray("_package");
        for (StringType e : element.getPackage())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasFormatElement()) {
      composeCodeCore("format", element.getFormatElement(), false);
      composeCodeExtras("format", element.getFormatElement(), false);
    }
    if (element.hasPage()) {
      openArray("page");
      for (ImplementationGuide.ImplementationGuidePageComponent e : element.getPage())
        composeImplementationGuideImplementationGuidePageComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeList_(String name, List_ element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeList_Inner(element);
    }
  }

  protected void composeList_Inner(List_ element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new List_.ListStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new List_.ListStatusEnumFactory(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasOrderedBy()) {
      composeCodeableConcept("orderedBy", element.getOrderedBy());
    }
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new List_.ListModeEnumFactory(), false);
      composeEnumerationExtras("mode", element.getModeElement(), new List_.ListModeEnumFactory(), false);
    }
    if (element.hasNoteElement()) {
      composeStringCore("note", element.getNoteElement(), false);
      composeStringExtras("note", element.getNoteElement(), false);
    }
    if (element.hasEntry()) {
      openArray("entry");
      for (List_.ListEntryComponent e : element.getEntry())
        composeList_ListEntryComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEmptyReason()) {
      composeCodeableConcept("emptyReason", element.getEmptyReason());
    }
  }

  protected void composeList_ListEntryComponent(String name, List_.ListEntryComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeList_ListEntryComponentInner(element);
      close();
    }
  }

  protected void composeList_ListEntryComponentInner(List_.ListEntryComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasFlag()) {
      composeCodeableConcept("flag", element.getFlag());
    }
    if (element.hasDeletedElement()) {
      composeBooleanCore("deleted", element.getDeletedElement(), false);
      composeBooleanExtras("deleted", element.getDeletedElement(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasItem()) {
      composeReference("item", element.getItem());
    }
  }

  protected void composeLocation(String name, Location element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeLocationInner(element);
    }
  }

  protected void composeLocationInner(Location element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Location.LocationStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Location.LocationStatusEnumFactory(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasModeElement()) {
      composeEnumerationCore("mode", element.getModeElement(), new Location.LocationModeEnumFactory(), false);
      composeEnumerationExtras("mode", element.getModeElement(), new Location.LocationModeEnumFactory(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasAddress()) {
      composeAddress("address", element.getAddress());
    }
    if (element.hasPhysicalType()) {
      composeCodeableConcept("physicalType", element.getPhysicalType());
    }
    if (element.hasPosition()) {
      composeLocationLocationPositionComponent("position", element.getPosition());
    }
    if (element.hasManagingOrganization()) {
      composeReference("managingOrganization", element.getManagingOrganization());
    }
    if (element.hasPartOf()) {
      composeReference("partOf", element.getPartOf());
    }
  }

  protected void composeLocationLocationPositionComponent(String name, Location.LocationPositionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeLocationLocationPositionComponentInner(element);
      close();
    }
  }

  protected void composeLocationLocationPositionComponentInner(Location.LocationPositionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLongitudeElement()) {
      composeDecimalCore("longitude", element.getLongitudeElement(), false);
      composeDecimalExtras("longitude", element.getLongitudeElement(), false);
    }
    if (element.hasLatitudeElement()) {
      composeDecimalCore("latitude", element.getLatitudeElement(), false);
      composeDecimalExtras("latitude", element.getLatitudeElement(), false);
    }
    if (element.hasAltitudeElement()) {
      composeDecimalCore("altitude", element.getAltitudeElement(), false);
      composeDecimalExtras("altitude", element.getAltitudeElement(), false);
    }
  }

  protected void composeMedia(String name, Media element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMediaInner(element);
    }
  }

  protected void composeMediaInner(Media element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Media.DigitalMediaTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Media.DigitalMediaTypeEnumFactory(), false);
    }
    if (element.hasSubtype()) {
      composeCodeableConcept("subtype", element.getSubtype());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasOperator()) {
      composeReference("operator", element.getOperator());
    }
    if (element.hasView()) {
      composeCodeableConcept("view", element.getView());
    }
    if (element.hasDeviceNameElement()) {
      composeStringCore("deviceName", element.getDeviceNameElement(), false);
      composeStringExtras("deviceName", element.getDeviceNameElement(), false);
    }
    if (element.hasHeightElement()) {
      composePositiveIntCore("height", element.getHeightElement(), false);
      composePositiveIntExtras("height", element.getHeightElement(), false);
    }
    if (element.hasWidthElement()) {
      composePositiveIntCore("width", element.getWidthElement(), false);
      composePositiveIntExtras("width", element.getWidthElement(), false);
    }
    if (element.hasFramesElement()) {
      composePositiveIntCore("frames", element.getFramesElement(), false);
      composePositiveIntExtras("frames", element.getFramesElement(), false);
    }
    if (element.hasDurationElement()) {
      composeUnsignedIntCore("duration", element.getDurationElement(), false);
      composeUnsignedIntExtras("duration", element.getDurationElement(), false);
    }
    if (element.hasContent()) {
      composeAttachment("content", element.getContent());
    }
  }

  protected void composeMedication(String name, Medication element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMedicationInner(element);
    }
  }

  protected void composeMedicationInner(Medication element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasIsBrandElement()) {
      composeBooleanCore("isBrand", element.getIsBrandElement(), false);
      composeBooleanExtras("isBrand", element.getIsBrandElement(), false);
    }
    if (element.hasManufacturer()) {
      composeReference("manufacturer", element.getManufacturer());
    }
    if (element.hasProduct()) {
      composeMedicationMedicationProductComponent("product", element.getProduct());
    }
    if (element.hasPackage()) {
      composeMedicationMedicationPackageComponent("package", element.getPackage());
    }
  }

  protected void composeMedicationMedicationProductComponent(String name, Medication.MedicationProductComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeMedicationMedicationProductComponentInner(element);
      close();
    }
  }

  protected void composeMedicationMedicationProductComponentInner(Medication.MedicationProductComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasForm()) {
      composeCodeableConcept("form", element.getForm());
    }
    if (element.hasIngredient()) {
      openArray("ingredient");
      for (Medication.MedicationProductIngredientComponent e : element.getIngredient())
        composeMedicationMedicationProductIngredientComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasBatch()) {
      openArray("batch");
      for (Medication.MedicationProductBatchComponent e : element.getBatch())
        composeMedicationMedicationProductBatchComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeMedicationMedicationProductIngredientComponent(String name,
      Medication.MedicationProductIngredientComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationMedicationProductIngredientComponentInner(element);
      close();
    }
  }

  protected void composeMedicationMedicationProductIngredientComponentInner(
      Medication.MedicationProductIngredientComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasItem()) {
      composeReference("item", element.getItem());
    }
    if (element.hasAmount()) {
      composeRatio("amount", element.getAmount());
    }
  }

  protected void composeMedicationMedicationProductBatchComponent(String name,
      Medication.MedicationProductBatchComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationMedicationProductBatchComponentInner(element);
      close();
    }
  }

  protected void composeMedicationMedicationProductBatchComponentInner(
      Medication.MedicationProductBatchComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLotNumberElement()) {
      composeStringCore("lotNumber", element.getLotNumberElement(), false);
      composeStringExtras("lotNumber", element.getLotNumberElement(), false);
    }
    if (element.hasExpirationDateElement()) {
      composeDateTimeCore("expirationDate", element.getExpirationDateElement(), false);
      composeDateTimeExtras("expirationDate", element.getExpirationDateElement(), false);
    }
  }

  protected void composeMedicationMedicationPackageComponent(String name, Medication.MedicationPackageComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeMedicationMedicationPackageComponentInner(element);
      close();
    }
  }

  protected void composeMedicationMedicationPackageComponentInner(Medication.MedicationPackageComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasContainer()) {
      composeCodeableConcept("container", element.getContainer());
    }
    if (element.hasContent()) {
      openArray("content");
      for (Medication.MedicationPackageContentComponent e : element.getContent())
        composeMedicationMedicationPackageContentComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeMedicationMedicationPackageContentComponent(String name,
      Medication.MedicationPackageContentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationMedicationPackageContentComponentInner(element);
      close();
    }
  }

  protected void composeMedicationMedicationPackageContentComponentInner(
      Medication.MedicationPackageContentComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasItem()) {
      composeReference("item", element.getItem());
    }
    if (element.hasAmount()) {
      composeSimpleQuantity("amount", element.getAmount());
    }
  }

  protected void composeMedicationAdministration(String name, MedicationAdministration element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMedicationAdministrationInner(element);
    }
  }

  protected void composeMedicationAdministrationInner(MedicationAdministration element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new MedicationAdministration.MedicationAdministrationStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new MedicationAdministration.MedicationAdministrationStatusEnumFactory(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasPractitioner()) {
      composeReference("practitioner", element.getPractitioner());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasPrescription()) {
      composeReference("prescription", element.getPrescription());
    }
    if (element.hasWasNotGivenElement()) {
      composeBooleanCore("wasNotGiven", element.getWasNotGivenElement(), false);
      composeBooleanExtras("wasNotGiven", element.getWasNotGivenElement(), false);
    }
    if (element.hasReasonNotGiven()) {
      openArray("reasonNotGiven");
      for (CodeableConcept e : element.getReasonNotGiven())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReasonGiven()) {
      openArray("reasonGiven");
      for (CodeableConcept e : element.getReasonGiven())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasEffectiveTime()) {
      composeType("effectiveTime", element.getEffectiveTime());
    }
    if (element.hasMedication()) {
      composeType("medication", element.getMedication());
    }
    if (element.hasDevice()) {
      openArray("device");
      for (Reference e : element.getDevice())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasNoteElement()) {
      composeStringCore("note", element.getNoteElement(), false);
      composeStringExtras("note", element.getNoteElement(), false);
    }
    if (element.hasDosage()) {
      composeMedicationAdministrationMedicationAdministrationDosageComponent("dosage", element.getDosage());
    }
  }

  protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(String name,
      MedicationAdministration.MedicationAdministrationDosageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationAdministrationMedicationAdministrationDosageComponentInner(element);
      close();
    }
  }

  protected void composeMedicationAdministrationMedicationAdministrationDosageComponentInner(
      MedicationAdministration.MedicationAdministrationDosageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasSite()) {
      composeType("site", element.getSite());
    }
    if (element.hasRoute()) {
      composeCodeableConcept("route", element.getRoute());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasRate()) {
      composeType("rate", element.getRate());
    }
  }

  protected void composeMedicationDispense(String name, MedicationDispense element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMedicationDispenseInner(element);
    }
  }

  protected void composeMedicationDispenseInner(MedicationDispense element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new MedicationDispense.MedicationDispenseStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new MedicationDispense.MedicationDispenseStatusEnumFactory(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasDispenser()) {
      composeReference("dispenser", element.getDispenser());
    }
    if (element.hasAuthorizingPrescription()) {
      openArray("authorizingPrescription");
      for (Reference e : element.getAuthorizingPrescription())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasDaysSupply()) {
      composeSimpleQuantity("daysSupply", element.getDaysSupply());
    }
    if (element.hasMedication()) {
      composeType("medication", element.getMedication());
    }
    if (element.hasWhenPreparedElement()) {
      composeDateTimeCore("whenPrepared", element.getWhenPreparedElement(), false);
      composeDateTimeExtras("whenPrepared", element.getWhenPreparedElement(), false);
    }
    if (element.hasWhenHandedOverElement()) {
      composeDateTimeCore("whenHandedOver", element.getWhenHandedOverElement(), false);
      composeDateTimeExtras("whenHandedOver", element.getWhenHandedOverElement(), false);
    }
    if (element.hasDestination()) {
      composeReference("destination", element.getDestination());
    }
    if (element.hasReceiver()) {
      openArray("receiver");
      for (Reference e : element.getReceiver())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasNoteElement()) {
      composeStringCore("note", element.getNoteElement(), false);
      composeStringExtras("note", element.getNoteElement(), false);
    }
    if (element.hasDosageInstruction()) {
      openArray("dosageInstruction");
      for (MedicationDispense.MedicationDispenseDosageInstructionComponent e : element.getDosageInstruction())
        composeMedicationDispenseMedicationDispenseDosageInstructionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSubstitution()) {
      composeMedicationDispenseMedicationDispenseSubstitutionComponent("substitution", element.getSubstitution());
    }
  }

  protected void composeMedicationDispenseMedicationDispenseDosageInstructionComponent(String name,
      MedicationDispense.MedicationDispenseDosageInstructionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationDispenseMedicationDispenseDosageInstructionComponentInner(element);
      close();
    }
  }

  protected void composeMedicationDispenseMedicationDispenseDosageInstructionComponentInner(
      MedicationDispense.MedicationDispenseDosageInstructionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasAdditionalInstructions()) {
      composeCodeableConcept("additionalInstructions", element.getAdditionalInstructions());
    }
    if (element.hasTiming()) {
      composeTiming("timing", element.getTiming());
    }
    if (element.hasAsNeeded()) {
      composeType("asNeeded", element.getAsNeeded());
    }
    if (element.hasSite()) {
      composeType("site", element.getSite());
    }
    if (element.hasRoute()) {
      composeCodeableConcept("route", element.getRoute());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasDose()) {
      composeType("dose", element.getDose());
    }
    if (element.hasRate()) {
      composeType("rate", element.getRate());
    }
    if (element.hasMaxDosePerPeriod()) {
      composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
    }
  }

  protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(String name,
      MedicationDispense.MedicationDispenseSubstitutionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationDispenseMedicationDispenseSubstitutionComponentInner(element);
      close();
    }
  }

  protected void composeMedicationDispenseMedicationDispenseSubstitutionComponentInner(
      MedicationDispense.MedicationDispenseSubstitutionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasResponsibleParty()) {
      openArray("responsibleParty");
      for (Reference e : element.getResponsibleParty())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeMedicationOrder(String name, MedicationOrder element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMedicationOrderInner(element);
    }
  }

  protected void composeMedicationOrderInner(MedicationOrder element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasDateWrittenElement()) {
      composeDateTimeCore("dateWritten", element.getDateWrittenElement(), false);
      composeDateTimeExtras("dateWritten", element.getDateWrittenElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new MedicationOrder.MedicationOrderStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new MedicationOrder.MedicationOrderStatusEnumFactory(), false);
    }
    if (element.hasDateEndedElement()) {
      composeDateTimeCore("dateEnded", element.getDateEndedElement(), false);
      composeDateTimeExtras("dateEnded", element.getDateEndedElement(), false);
    }
    if (element.hasReasonEnded()) {
      composeCodeableConcept("reasonEnded", element.getReasonEnded());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasPrescriber()) {
      composeReference("prescriber", element.getPrescriber());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasNoteElement()) {
      composeStringCore("note", element.getNoteElement(), false);
      composeStringExtras("note", element.getNoteElement(), false);
    }
    if (element.hasMedication()) {
      composeType("medication", element.getMedication());
    }
    if (element.hasDosageInstruction()) {
      openArray("dosageInstruction");
      for (MedicationOrder.MedicationOrderDosageInstructionComponent e : element.getDosageInstruction())
        composeMedicationOrderMedicationOrderDosageInstructionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDispenseRequest()) {
      composeMedicationOrderMedicationOrderDispenseRequestComponent("dispenseRequest", element.getDispenseRequest());
    }
    if (element.hasSubstitution()) {
      composeMedicationOrderMedicationOrderSubstitutionComponent("substitution", element.getSubstitution());
    }
    if (element.hasPriorPrescription()) {
      composeReference("priorPrescription", element.getPriorPrescription());
    }
  }

  protected void composeMedicationOrderMedicationOrderDosageInstructionComponent(String name,
      MedicationOrder.MedicationOrderDosageInstructionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationOrderMedicationOrderDosageInstructionComponentInner(element);
      close();
    }
  }

  protected void composeMedicationOrderMedicationOrderDosageInstructionComponentInner(
      MedicationOrder.MedicationOrderDosageInstructionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasAdditionalInstructions()) {
      composeCodeableConcept("additionalInstructions", element.getAdditionalInstructions());
    }
    if (element.hasTiming()) {
      composeTiming("timing", element.getTiming());
    }
    if (element.hasAsNeeded()) {
      composeType("asNeeded", element.getAsNeeded());
    }
    if (element.hasSite()) {
      composeType("site", element.getSite());
    }
    if (element.hasRoute()) {
      composeCodeableConcept("route", element.getRoute());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasDose()) {
      composeType("dose", element.getDose());
    }
    if (element.hasRate()) {
      composeType("rate", element.getRate());
    }
    if (element.hasMaxDosePerPeriod()) {
      composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
    }
  }

  protected void composeMedicationOrderMedicationOrderDispenseRequestComponent(String name,
      MedicationOrder.MedicationOrderDispenseRequestComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationOrderMedicationOrderDispenseRequestComponentInner(element);
      close();
    }
  }

  protected void composeMedicationOrderMedicationOrderDispenseRequestComponentInner(
      MedicationOrder.MedicationOrderDispenseRequestComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasMedication()) {
      composeType("medication", element.getMedication());
    }
    if (element.hasValidityPeriod()) {
      composePeriod("validityPeriod", element.getValidityPeriod());
    }
    if (element.hasNumberOfRepeatsAllowedElement()) {
      composePositiveIntCore("numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), false);
      composePositiveIntExtras("numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), false);
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasExpectedSupplyDuration()) {
      composeDuration("expectedSupplyDuration", element.getExpectedSupplyDuration());
    }
  }

  protected void composeMedicationOrderMedicationOrderSubstitutionComponent(String name,
      MedicationOrder.MedicationOrderSubstitutionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationOrderMedicationOrderSubstitutionComponentInner(element);
      close();
    }
  }

  protected void composeMedicationOrderMedicationOrderSubstitutionComponentInner(
      MedicationOrder.MedicationOrderSubstitutionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasReason()) {
      composeCodeableConcept("reason", element.getReason());
    }
  }

  protected void composeMedicationStatement(String name, MedicationStatement element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMedicationStatementInner(element);
    }
  }

  protected void composeMedicationStatementInner(MedicationStatement element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasInformationSource()) {
      composeReference("informationSource", element.getInformationSource());
    }
    if (element.hasDateAssertedElement()) {
      composeDateTimeCore("dateAsserted", element.getDateAssertedElement(), false);
      composeDateTimeExtras("dateAsserted", element.getDateAssertedElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new MedicationStatement.MedicationStatementStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new MedicationStatement.MedicationStatementStatusEnumFactory(), false);
    }
    if (element.hasWasNotTakenElement()) {
      composeBooleanCore("wasNotTaken", element.getWasNotTakenElement(), false);
      composeBooleanExtras("wasNotTaken", element.getWasNotTakenElement(), false);
    }
    if (element.hasReasonNotTaken()) {
      openArray("reasonNotTaken");
      for (CodeableConcept e : element.getReasonNotTaken())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReasonForUse()) {
      composeType("reasonForUse", element.getReasonForUse());
    }
    if (element.hasEffective()) {
      composeType("effective", element.getEffective());
    }
    if (element.hasNoteElement()) {
      composeStringCore("note", element.getNoteElement(), false);
      composeStringExtras("note", element.getNoteElement(), false);
    }
    if (element.hasSupportingInformation()) {
      openArray("supportingInformation");
      for (Reference e : element.getSupportingInformation())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasMedication()) {
      composeType("medication", element.getMedication());
    }
    if (element.hasDosage()) {
      openArray("dosage");
      for (MedicationStatement.MedicationStatementDosageComponent e : element.getDosage())
        composeMedicationStatementMedicationStatementDosageComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeMedicationStatementMedicationStatementDosageComponent(String name,
      MedicationStatement.MedicationStatementDosageComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMedicationStatementMedicationStatementDosageComponentInner(element);
      close();
    }
  }

  protected void composeMedicationStatementMedicationStatementDosageComponentInner(
      MedicationStatement.MedicationStatementDosageComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasTiming()) {
      composeTiming("timing", element.getTiming());
    }
    if (element.hasAsNeeded()) {
      composeType("asNeeded", element.getAsNeeded());
    }
    if (element.hasSite()) {
      composeType("site", element.getSite());
    }
    if (element.hasRoute()) {
      composeCodeableConcept("route", element.getRoute());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasQuantity()) {
      composeType("quantity", element.getQuantity());
    }
    if (element.hasRate()) {
      composeType("rate", element.getRate());
    }
    if (element.hasMaxDosePerPeriod()) {
      composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
    }
  }

  protected void composeMessageHeader(String name, MessageHeader element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeMessageHeaderInner(element);
    }
  }

  protected void composeMessageHeaderInner(MessageHeader element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasTimestampElement()) {
      composeInstantCore("timestamp", element.getTimestampElement(), false);
      composeInstantExtras("timestamp", element.getTimestampElement(), false);
    }
    if (element.hasEvent()) {
      composeCoding("event", element.getEvent());
    }
    if (element.hasResponse()) {
      composeMessageHeaderMessageHeaderResponseComponent("response", element.getResponse());
    }
    if (element.hasSource()) {
      composeMessageHeaderMessageSourceComponent("source", element.getSource());
    }
    if (element.hasDestination()) {
      openArray("destination");
      for (MessageHeader.MessageDestinationComponent e : element.getDestination())
        composeMessageHeaderMessageDestinationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEnterer()) {
      composeReference("enterer", element.getEnterer());
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasReceiver()) {
      composeReference("receiver", element.getReceiver());
    }
    if (element.hasResponsible()) {
      composeReference("responsible", element.getResponsible());
    }
    if (element.hasReason()) {
      composeCodeableConcept("reason", element.getReason());
    }
    if (element.hasData()) {
      openArray("data");
      for (Reference e : element.getData())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeMessageHeaderMessageHeaderResponseComponent(String name,
      MessageHeader.MessageHeaderResponseComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMessageHeaderMessageHeaderResponseComponentInner(element);
      close();
    }
  }

  protected void composeMessageHeaderMessageHeaderResponseComponentInner(
      MessageHeader.MessageHeaderResponseComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentifierElement()) {
      composeIdCore("identifier", element.getIdentifierElement(), false);
      composeIdExtras("identifier", element.getIdentifierElement(), false);
    }
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(), new MessageHeader.ResponseTypeEnumFactory(), false);
      composeEnumerationExtras("code", element.getCodeElement(), new MessageHeader.ResponseTypeEnumFactory(), false);
    }
    if (element.hasDetails()) {
      composeReference("details", element.getDetails());
    }
  }

  protected void composeMessageHeaderMessageSourceComponent(String name, MessageHeader.MessageSourceComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeMessageHeaderMessageSourceComponentInner(element);
      close();
    }
  }

  protected void composeMessageHeaderMessageSourceComponentInner(MessageHeader.MessageSourceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasSoftwareElement()) {
      composeStringCore("software", element.getSoftwareElement(), false);
      composeStringExtras("software", element.getSoftwareElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasContact()) {
      composeContactPoint("contact", element.getContact());
    }
    if (element.hasEndpointElement()) {
      composeUriCore("endpoint", element.getEndpointElement(), false);
      composeUriExtras("endpoint", element.getEndpointElement(), false);
    }
  }

  protected void composeMessageHeaderMessageDestinationComponent(String name,
      MessageHeader.MessageDestinationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeMessageHeaderMessageDestinationComponentInner(element);
      close();
    }
  }

  protected void composeMessageHeaderMessageDestinationComponentInner(MessageHeader.MessageDestinationComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasEndpointElement()) {
      composeUriCore("endpoint", element.getEndpointElement(), false);
      composeUriExtras("endpoint", element.getEndpointElement(), false);
    }
  }

  protected void composeNamingSystem(String name, NamingSystem element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeNamingSystemInner(element);
    }
  }

  protected void composeNamingSystemInner(NamingSystem element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasKindElement()) {
      composeEnumerationCore("kind", element.getKindElement(), new NamingSystem.NamingSystemTypeEnumFactory(), false);
      composeEnumerationExtras("kind", element.getKindElement(), new NamingSystem.NamingSystemTypeEnumFactory(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (NamingSystem.NamingSystemContactComponent e : element.getContact())
        composeNamingSystemNamingSystemContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasResponsibleElement()) {
      composeStringCore("responsible", element.getResponsibleElement(), false);
      composeStringExtras("responsible", element.getResponsibleElement(), false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasUsageElement()) {
      composeStringCore("usage", element.getUsageElement(), false);
      composeStringExtras("usage", element.getUsageElement(), false);
    }
    if (element.hasUniqueId()) {
      openArray("uniqueId");
      for (NamingSystem.NamingSystemUniqueIdComponent e : element.getUniqueId())
        composeNamingSystemNamingSystemUniqueIdComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasReplacedBy()) {
      composeReference("replacedBy", element.getReplacedBy());
    }
  }

  protected void composeNamingSystemNamingSystemContactComponent(String name,
      NamingSystem.NamingSystemContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNamingSystemNamingSystemContactComponentInner(element);
      close();
    }
  }

  protected void composeNamingSystemNamingSystemContactComponentInner(NamingSystem.NamingSystemContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeNamingSystemNamingSystemUniqueIdComponent(String name,
      NamingSystem.NamingSystemUniqueIdComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNamingSystemNamingSystemUniqueIdComponentInner(element);
      close();
    }
  }

  protected void composeNamingSystemNamingSystemUniqueIdComponentInner(
      NamingSystem.NamingSystemUniqueIdComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new NamingSystem.NamingSystemIdentifierTypeEnumFactory(),
          false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new NamingSystem.NamingSystemIdentifierTypeEnumFactory(), false);
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
    if (element.hasPreferredElement()) {
      composeBooleanCore("preferred", element.getPreferredElement(), false);
      composeBooleanExtras("preferred", element.getPreferredElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeNutritionOrder(String name, NutritionOrder element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeNutritionOrderInner(element);
    }
  }

  protected void composeNutritionOrderInner(NutritionOrder element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasOrderer()) {
      composeReference("orderer", element.getOrderer());
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasDateTimeElement()) {
      composeDateTimeCore("dateTime", element.getDateTimeElement(), false);
      composeDateTimeExtras("dateTime", element.getDateTimeElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new NutritionOrder.NutritionOrderStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new NutritionOrder.NutritionOrderStatusEnumFactory(), false);
    }
    if (element.hasAllergyIntolerance()) {
      openArray("allergyIntolerance");
      for (Reference e : element.getAllergyIntolerance())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasFoodPreferenceModifier()) {
      openArray("foodPreferenceModifier");
      for (CodeableConcept e : element.getFoodPreferenceModifier())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasExcludeFoodModifier()) {
      openArray("excludeFoodModifier");
      for (CodeableConcept e : element.getExcludeFoodModifier())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasOralDiet()) {
      composeNutritionOrderNutritionOrderOralDietComponent("oralDiet", element.getOralDiet());
    }
    if (element.hasSupplement()) {
      openArray("supplement");
      for (NutritionOrder.NutritionOrderSupplementComponent e : element.getSupplement())
        composeNutritionOrderNutritionOrderSupplementComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEnteralFormula()) {
      composeNutritionOrderNutritionOrderEnteralFormulaComponent("enteralFormula", element.getEnteralFormula());
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietComponent(String name,
      NutritionOrder.NutritionOrderOralDietComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderOralDietComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietComponentInner(
      NutritionOrder.NutritionOrderOralDietComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSchedule()) {
      openArray("schedule");
      for (Timing e : element.getSchedule())
        composeTiming(null, e);
      closeArray();
    }
    ;
    if (element.hasNutrient()) {
      openArray("nutrient");
      for (NutritionOrder.NutritionOrderOralDietNutrientComponent e : element.getNutrient())
        composeNutritionOrderNutritionOrderOralDietNutrientComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTexture()) {
      openArray("texture");
      for (NutritionOrder.NutritionOrderOralDietTextureComponent e : element.getTexture())
        composeNutritionOrderNutritionOrderOralDietTextureComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasFluidConsistencyType()) {
      openArray("fluidConsistencyType");
      for (CodeableConcept e : element.getFluidConsistencyType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasInstructionElement()) {
      composeStringCore("instruction", element.getInstructionElement(), false);
      composeStringExtras("instruction", element.getInstructionElement(), false);
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(String name,
      NutritionOrder.NutritionOrderOralDietNutrientComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderOralDietNutrientComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietNutrientComponentInner(
      NutritionOrder.NutritionOrderOralDietNutrientComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasModifier()) {
      composeCodeableConcept("modifier", element.getModifier());
    }
    if (element.hasAmount()) {
      composeSimpleQuantity("amount", element.getAmount());
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(String name,
      NutritionOrder.NutritionOrderOralDietTextureComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderOralDietTextureComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderOralDietTextureComponentInner(
      NutritionOrder.NutritionOrderOralDietTextureComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasModifier()) {
      composeCodeableConcept("modifier", element.getModifier());
    }
    if (element.hasFoodType()) {
      composeCodeableConcept("foodType", element.getFoodType());
    }
  }

  protected void composeNutritionOrderNutritionOrderSupplementComponent(String name,
      NutritionOrder.NutritionOrderSupplementComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderSupplementComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderSupplementComponentInner(
      NutritionOrder.NutritionOrderSupplementComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasProductNameElement()) {
      composeStringCore("productName", element.getProductNameElement(), false);
      composeStringExtras("productName", element.getProductNameElement(), false);
    }
    if (element.hasSchedule()) {
      openArray("schedule");
      for (Timing e : element.getSchedule())
        composeTiming(null, e);
      closeArray();
    }
    ;
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasInstructionElement()) {
      composeStringCore("instruction", element.getInstructionElement(), false);
      composeStringExtras("instruction", element.getInstructionElement(), false);
    }
  }

  protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(String name,
      NutritionOrder.NutritionOrderEnteralFormulaComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderEnteralFormulaComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderEnteralFormulaComponentInner(
      NutritionOrder.NutritionOrderEnteralFormulaComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasBaseFormulaType()) {
      composeCodeableConcept("baseFormulaType", element.getBaseFormulaType());
    }
    if (element.hasBaseFormulaProductNameElement()) {
      composeStringCore("baseFormulaProductName", element.getBaseFormulaProductNameElement(), false);
      composeStringExtras("baseFormulaProductName", element.getBaseFormulaProductNameElement(), false);
    }
    if (element.hasAdditiveType()) {
      composeCodeableConcept("additiveType", element.getAdditiveType());
    }
    if (element.hasAdditiveProductNameElement()) {
      composeStringCore("additiveProductName", element.getAdditiveProductNameElement(), false);
      composeStringExtras("additiveProductName", element.getAdditiveProductNameElement(), false);
    }
    if (element.hasCaloricDensity()) {
      composeSimpleQuantity("caloricDensity", element.getCaloricDensity());
    }
    if (element.hasRouteofAdministration()) {
      composeCodeableConcept("routeofAdministration", element.getRouteofAdministration());
    }
    if (element.hasAdministration()) {
      openArray("administration");
      for (NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent e : element.getAdministration())
        composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMaxVolumeToDeliver()) {
      composeSimpleQuantity("maxVolumeToDeliver", element.getMaxVolumeToDeliver());
    }
    if (element.hasAdministrationInstructionElement()) {
      composeStringCore("administrationInstruction", element.getAdministrationInstructionElement(), false);
      composeStringExtras("administrationInstruction", element.getAdministrationInstructionElement(), false);
    }
  }

  protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(String name,
      NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentInner(element);
      close();
    }
  }

  protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentInner(
      NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSchedule()) {
      composeTiming("schedule", element.getSchedule());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasRate()) {
      composeType("rate", element.getRate());
    }
  }

  protected void composeObservation(String name, Observation element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeObservationInner(element);
    }
  }

  protected void composeObservationInner(Observation element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Observation.ObservationStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Observation.ObservationStatusEnumFactory(),
          false);
    }
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasEffective()) {
      composeType("effective", element.getEffective());
    }
    if (element.hasIssuedElement()) {
      composeInstantCore("issued", element.getIssuedElement(), false);
      composeInstantExtras("issued", element.getIssuedElement(), false);
    }
    if (element.hasPerformer()) {
      openArray("performer");
      for (Reference e : element.getPerformer())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
    if (element.hasDataAbsentReason()) {
      composeCodeableConcept("dataAbsentReason", element.getDataAbsentReason());
    }
    if (element.hasInterpretation()) {
      composeCodeableConcept("interpretation", element.getInterpretation());
    }
    if (element.hasCommentsElement()) {
      composeStringCore("comments", element.getCommentsElement(), false);
      composeStringExtras("comments", element.getCommentsElement(), false);
    }
    if (element.hasBodySite()) {
      composeCodeableConcept("bodySite", element.getBodySite());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasSpecimen()) {
      composeReference("specimen", element.getSpecimen());
    }
    if (element.hasDevice()) {
      composeReference("device", element.getDevice());
    }
    if (element.hasReferenceRange()) {
      openArray("referenceRange");
      for (Observation.ObservationReferenceRangeComponent e : element.getReferenceRange())
        composeObservationObservationReferenceRangeComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasRelated()) {
      openArray("related");
      for (Observation.ObservationRelatedComponent e : element.getRelated())
        composeObservationObservationRelatedComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasComponent()) {
      openArray("component");
      for (Observation.ObservationComponentComponent e : element.getComponent())
        composeObservationObservationComponentComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeObservationObservationReferenceRangeComponent(String name,
      Observation.ObservationReferenceRangeComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeObservationObservationReferenceRangeComponentInner(element);
      close();
    }
  }

  protected void composeObservationObservationReferenceRangeComponentInner(
      Observation.ObservationReferenceRangeComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLow()) {
      composeSimpleQuantity("low", element.getLow());
    }
    if (element.hasHigh()) {
      composeSimpleQuantity("high", element.getHigh());
    }
    if (element.hasMeaning()) {
      composeCodeableConcept("meaning", element.getMeaning());
    }
    if (element.hasAge()) {
      composeRange("age", element.getAge());
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composeObservationObservationRelatedComponent(String name,
      Observation.ObservationRelatedComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeObservationObservationRelatedComponentInner(element);
      close();
    }
  }

  protected void composeObservationObservationRelatedComponentInner(Observation.ObservationRelatedComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Observation.ObservationRelationshipTypeEnumFactory(),
          false);
      composeEnumerationExtras("type", element.getTypeElement(),
          new Observation.ObservationRelationshipTypeEnumFactory(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
  }

  protected void composeObservationObservationComponentComponent(String name,
      Observation.ObservationComponentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeObservationObservationComponentComponentInner(element);
      close();
    }
  }

  protected void composeObservationObservationComponentComponentInner(Observation.ObservationComponentComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
    if (element.hasDataAbsentReason()) {
      composeCodeableConcept("dataAbsentReason", element.getDataAbsentReason());
    }
    if (element.hasReferenceRange()) {
      openArray("referenceRange");
      for (Observation.ObservationReferenceRangeComponent e : element.getReferenceRange())
        composeObservationObservationReferenceRangeComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOperationDefinition(String name, OperationDefinition element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeOperationDefinitionInner(element);
    }
  }

  protected void composeOperationDefinitionInner(OperationDefinition element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasKindElement()) {
      composeEnumerationCore("kind", element.getKindElement(), new OperationDefinition.OperationKindEnumFactory(),
          false);
      composeEnumerationExtras("kind", element.getKindElement(), new OperationDefinition.OperationKindEnumFactory(),
          false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (OperationDefinition.OperationDefinitionContactComponent e : element.getContact())
        composeOperationDefinitionOperationDefinitionContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasIdempotentElement()) {
      composeBooleanCore("idempotent", element.getIdempotentElement(), false);
      composeBooleanExtras("idempotent", element.getIdempotentElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasNotesElement()) {
      composeStringCore("notes", element.getNotesElement(), false);
      composeStringExtras("notes", element.getNotesElement(), false);
    }
    if (element.hasBase()) {
      composeReference("base", element.getBase());
    }
    if (element.hasSystemElement()) {
      composeBooleanCore("system", element.getSystemElement(), false);
      composeBooleanExtras("system", element.getSystemElement(), false);
    }
    if (element.hasType()) {
      openArray("type");
      for (CodeType e : element.getType())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getType())) {
        openArray("_type");
        for (CodeType e : element.getType())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasInstanceElement()) {
      composeBooleanCore("instance", element.getInstanceElement(), false);
      composeBooleanExtras("instance", element.getInstanceElement(), false);
    }
    if (element.hasParameter()) {
      openArray("parameter");
      for (OperationDefinition.OperationDefinitionParameterComponent e : element.getParameter())
        composeOperationDefinitionOperationDefinitionParameterComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOperationDefinitionOperationDefinitionContactComponent(String name,
      OperationDefinition.OperationDefinitionContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOperationDefinitionOperationDefinitionContactComponentInner(element);
      close();
    }
  }

  protected void composeOperationDefinitionOperationDefinitionContactComponentInner(
      OperationDefinition.OperationDefinitionContactComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOperationDefinitionOperationDefinitionParameterComponent(String name,
      OperationDefinition.OperationDefinitionParameterComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOperationDefinitionOperationDefinitionParameterComponentInner(element);
      close();
    }
  }

  protected void composeOperationDefinitionOperationDefinitionParameterComponentInner(
      OperationDefinition.OperationDefinitionParameterComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeCodeCore("name", element.getNameElement(), false);
      composeCodeExtras("name", element.getNameElement(), false);
    }
    if (element.hasUseElement()) {
      composeEnumerationCore("use", element.getUseElement(), new OperationDefinition.OperationParameterUseEnumFactory(),
          false);
      composeEnumerationExtras("use", element.getUseElement(),
          new OperationDefinition.OperationParameterUseEnumFactory(), false);
    }
    if (element.hasMinElement()) {
      composeIntegerCore("min", element.getMinElement(), false);
      composeIntegerExtras("min", element.getMinElement(), false);
    }
    if (element.hasMaxElement()) {
      composeStringCore("max", element.getMaxElement(), false);
      composeStringExtras("max", element.getMaxElement(), false);
    }
    if (element.hasDocumentationElement()) {
      composeStringCore("documentation", element.getDocumentationElement(), false);
      composeStringExtras("documentation", element.getDocumentationElement(), false);
    }
    if (element.hasTypeElement()) {
      composeCodeCore("type", element.getTypeElement(), false);
      composeCodeExtras("type", element.getTypeElement(), false);
    }
    if (element.hasProfile()) {
      composeReference("profile", element.getProfile());
    }
    if (element.hasBinding()) {
      composeOperationDefinitionOperationDefinitionParameterBindingComponent("binding", element.getBinding());
    }
    if (element.hasPart()) {
      openArray("part");
      for (OperationDefinition.OperationDefinitionParameterComponent e : element.getPart())
        composeOperationDefinitionOperationDefinitionParameterComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(String name,
      OperationDefinition.OperationDefinitionParameterBindingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOperationDefinitionOperationDefinitionParameterBindingComponentInner(element);
      close();
    }
  }

  protected void composeOperationDefinitionOperationDefinitionParameterBindingComponentInner(
      OperationDefinition.OperationDefinitionParameterBindingComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasStrengthElement()) {
      composeEnumerationCore("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory(),
          false);
      composeEnumerationExtras("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory(),
          false);
    }
    if (element.hasValueSet()) {
      composeType("valueSet", element.getValueSet());
    }
  }

  protected void composeOperationOutcome(String name, OperationOutcome element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeOperationOutcomeInner(element);
    }
  }

  protected void composeOperationOutcomeInner(OperationOutcome element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIssue()) {
      openArray("issue");
      for (OperationOutcome.OperationOutcomeIssueComponent e : element.getIssue())
        composeOperationOutcomeOperationOutcomeIssueComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOperationOutcomeOperationOutcomeIssueComponent(String name,
      OperationOutcome.OperationOutcomeIssueComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOperationOutcomeOperationOutcomeIssueComponentInner(element);
      close();
    }
  }

  protected void composeOperationOutcomeOperationOutcomeIssueComponentInner(
      OperationOutcome.OperationOutcomeIssueComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSeverityElement()) {
      composeEnumerationCore("severity", element.getSeverityElement(), new OperationOutcome.IssueSeverityEnumFactory(),
          false);
      composeEnumerationExtras("severity", element.getSeverityElement(),
          new OperationOutcome.IssueSeverityEnumFactory(), false);
    }
    if (element.hasCodeElement()) {
      composeEnumerationCore("code", element.getCodeElement(), new OperationOutcome.IssueTypeEnumFactory(), false);
      composeEnumerationExtras("code", element.getCodeElement(), new OperationOutcome.IssueTypeEnumFactory(), false);
    }
    if (element.hasDetails()) {
      composeCodeableConcept("details", element.getDetails());
    }
    if (element.hasDiagnosticsElement()) {
      composeStringCore("diagnostics", element.getDiagnosticsElement(), false);
      composeStringExtras("diagnostics", element.getDiagnosticsElement(), false);
    }
    if (element.hasLocation()) {
      openArray("location");
      for (StringType e : element.getLocation())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getLocation())) {
        openArray("_location");
        for (StringType e : element.getLocation())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
  }

  protected void composeOrder(String name, Order element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeOrderInner(element);
    }
  }

  protected void composeOrderInner(Order element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasWhen()) {
      composeOrderOrderWhenComponent("when", element.getWhen());
    }
    if (element.hasDetail()) {
      openArray("detail");
      for (Reference e : element.getDetail())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOrderOrderWhenComponent(String name, Order.OrderWhenComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOrderOrderWhenComponentInner(element);
      close();
    }
  }

  protected void composeOrderOrderWhenComponentInner(Order.OrderWhenComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSchedule()) {
      composeTiming("schedule", element.getSchedule());
    }
  }

  protected void composeOrderResponse(String name, OrderResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeOrderResponseInner(element);
    }
  }

  protected void composeOrderResponseInner(OrderResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasWho()) {
      composeReference("who", element.getWho());
    }
    if (element.hasOrderStatusElement()) {
      composeEnumerationCore("orderStatus", element.getOrderStatusElement(), new OrderResponse.OrderStatusEnumFactory(),
          false);
      composeEnumerationExtras("orderStatus", element.getOrderStatusElement(),
          new OrderResponse.OrderStatusEnumFactory(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasFulfillment()) {
      openArray("fulfillment");
      for (Reference e : element.getFulfillment())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOrganization(String name, Organization element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeOrganizationInner(element);
    }
  }

  protected void composeOrganizationInner(Organization element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasActiveElement()) {
      composeBooleanCore("active", element.getActiveElement(), false);
      composeBooleanExtras("active", element.getActiveElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasAddress()) {
      openArray("address");
      for (Address e : element.getAddress())
        composeAddress(null, e);
      closeArray();
    }
    ;
    if (element.hasPartOf()) {
      composeReference("partOf", element.getPartOf());
    }
    if (element.hasContact()) {
      openArray("contact");
      for (Organization.OrganizationContactComponent e : element.getContact())
        composeOrganizationOrganizationContactComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeOrganizationOrganizationContactComponent(String name,
      Organization.OrganizationContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeOrganizationOrganizationContactComponentInner(element);
      close();
    }
  }

  protected void composeOrganizationOrganizationContactComponentInner(Organization.OrganizationContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasPurpose()) {
      composeCodeableConcept("purpose", element.getPurpose());
    }
    if (element.hasName()) {
      composeHumanName("name", element.getName());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasAddress()) {
      composeAddress("address", element.getAddress());
    }
  }

  protected void composePatient(String name, Patient element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composePatientInner(element);
    }
  }

  protected void composePatientInner(Patient element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasActiveElement()) {
      composeBooleanCore("active", element.getActiveElement(), false);
      composeBooleanExtras("active", element.getActiveElement(), false);
    }
    if (element.hasName()) {
      openArray("name");
      for (HumanName e : element.getName())
        composeHumanName(null, e);
      closeArray();
    }
    ;
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasBirthDateElement()) {
      composeDateCore("birthDate", element.getBirthDateElement(), false);
      composeDateExtras("birthDate", element.getBirthDateElement(), false);
    }
    if (element.hasDeceased()) {
      composeType("deceased", element.getDeceased());
    }
    if (element.hasAddress()) {
      openArray("address");
      for (Address e : element.getAddress())
        composeAddress(null, e);
      closeArray();
    }
    ;
    if (element.hasMaritalStatus()) {
      composeCodeableConcept("maritalStatus", element.getMaritalStatus());
    }
    if (element.hasMultipleBirth()) {
      composeType("multipleBirth", element.getMultipleBirth());
    }
    if (element.hasPhoto()) {
      openArray("photo");
      for (Attachment e : element.getPhoto())
        composeAttachment(null, e);
      closeArray();
    }
    ;
    if (element.hasContact()) {
      openArray("contact");
      for (Patient.ContactComponent e : element.getContact())
        composePatientContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasAnimal()) {
      composePatientAnimalComponent("animal", element.getAnimal());
    }
    if (element.hasCommunication()) {
      openArray("communication");
      for (Patient.PatientCommunicationComponent e : element.getCommunication())
        composePatientPatientCommunicationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCareProvider()) {
      openArray("careProvider");
      for (Reference e : element.getCareProvider())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasManagingOrganization()) {
      composeReference("managingOrganization", element.getManagingOrganization());
    }
    if (element.hasLink()) {
      openArray("link");
      for (Patient.PatientLinkComponent e : element.getLink())
        composePatientPatientLinkComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composePatientContactComponent(String name, Patient.ContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePatientContactComponentInner(element);
      close();
    }
  }

  protected void composePatientContactComponentInner(Patient.ContactComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasRelationship()) {
      openArray("relationship");
      for (CodeableConcept e : element.getRelationship())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasName()) {
      composeHumanName("name", element.getName());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasAddress()) {
      composeAddress("address", element.getAddress());
    }
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composePatientAnimalComponent(String name, Patient.AnimalComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePatientAnimalComponentInner(element);
      close();
    }
  }

  protected void composePatientAnimalComponentInner(Patient.AnimalComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSpecies()) {
      composeCodeableConcept("species", element.getSpecies());
    }
    if (element.hasBreed()) {
      composeCodeableConcept("breed", element.getBreed());
    }
    if (element.hasGenderStatus()) {
      composeCodeableConcept("genderStatus", element.getGenderStatus());
    }
  }

  protected void composePatientPatientCommunicationComponent(String name, Patient.PatientCommunicationComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composePatientPatientCommunicationComponentInner(element);
      close();
    }
  }

  protected void composePatientPatientCommunicationComponentInner(Patient.PatientCommunicationComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLanguage()) {
      composeCodeableConcept("language", element.getLanguage());
    }
    if (element.hasPreferredElement()) {
      composeBooleanCore("preferred", element.getPreferredElement(), false);
      composeBooleanExtras("preferred", element.getPreferredElement(), false);
    }
  }

  protected void composePatientPatientLinkComponent(String name, Patient.PatientLinkComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composePatientPatientLinkComponentInner(element);
      close();
    }
  }

  protected void composePatientPatientLinkComponentInner(Patient.PatientLinkComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasOther()) {
      composeReference("other", element.getOther());
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Patient.LinkTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Patient.LinkTypeEnumFactory(), false);
    }
  }

  protected void composePaymentNotice(String name, PaymentNotice element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composePaymentNoticeInner(element);
    }
  }

  protected void composePaymentNoticeInner(PaymentNotice element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasResponse()) {
      composeReference("response", element.getResponse());
    }
    if (element.hasPaymentStatus()) {
      composeCoding("paymentStatus", element.getPaymentStatus());
    }
  }

  protected void composePaymentReconciliation(String name, PaymentReconciliation element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composePaymentReconciliationInner(element);
    }
  }

  protected void composePaymentReconciliationInner(PaymentReconciliation element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasOutcomeElement()) {
      composeEnumerationCore("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
      composeEnumerationExtras("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory(),
          false);
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
    if (element.hasDetail()) {
      openArray("detail");
      for (PaymentReconciliation.DetailsComponent e : element.getDetail())
        composePaymentReconciliationDetailsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasForm()) {
      composeCoding("form", element.getForm());
    }
    if (element.hasTotal()) {
      composeMoney("total", element.getTotal());
    }
    if (element.hasNote()) {
      openArray("note");
      for (PaymentReconciliation.NotesComponent e : element.getNote())
        composePaymentReconciliationNotesComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composePaymentReconciliationDetailsComponent(String name,
      PaymentReconciliation.DetailsComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePaymentReconciliationDetailsComponentInner(element);
      close();
    }
  }

  protected void composePaymentReconciliationDetailsComponentInner(PaymentReconciliation.DetailsComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasResponce()) {
      composeReference("responce", element.getResponce());
    }
    if (element.hasSubmitter()) {
      composeReference("submitter", element.getSubmitter());
    }
    if (element.hasPayee()) {
      composeReference("payee", element.getPayee());
    }
    if (element.hasDateElement()) {
      composeDateCore("date", element.getDateElement(), false);
      composeDateExtras("date", element.getDateElement(), false);
    }
    if (element.hasAmount()) {
      composeMoney("amount", element.getAmount());
    }
  }

  protected void composePaymentReconciliationNotesComponent(String name, PaymentReconciliation.NotesComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composePaymentReconciliationNotesComponentInner(element);
      close();
    }
  }

  protected void composePaymentReconciliationNotesComponentInner(PaymentReconciliation.NotesComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composePerson(String name, Person element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composePersonInner(element);
    }
  }

  protected void composePersonInner(Person element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasName()) {
      openArray("name");
      for (HumanName e : element.getName())
        composeHumanName(null, e);
      closeArray();
    }
    ;
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasBirthDateElement()) {
      composeDateCore("birthDate", element.getBirthDateElement(), false);
      composeDateExtras("birthDate", element.getBirthDateElement(), false);
    }
    if (element.hasAddress()) {
      openArray("address");
      for (Address e : element.getAddress())
        composeAddress(null, e);
      closeArray();
    }
    ;
    if (element.hasPhoto()) {
      composeAttachment("photo", element.getPhoto());
    }
    if (element.hasManagingOrganization()) {
      composeReference("managingOrganization", element.getManagingOrganization());
    }
    if (element.hasActiveElement()) {
      composeBooleanCore("active", element.getActiveElement(), false);
      composeBooleanExtras("active", element.getActiveElement(), false);
    }
    if (element.hasLink()) {
      openArray("link");
      for (Person.PersonLinkComponent e : element.getLink())
        composePersonPersonLinkComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composePersonPersonLinkComponent(String name, Person.PersonLinkComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePersonPersonLinkComponentInner(element);
      close();
    }
  }

  protected void composePersonPersonLinkComponentInner(Person.PersonLinkComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasAssuranceElement()) {
      composeEnumerationCore("assurance", element.getAssuranceElement(), new Person.IdentityAssuranceLevelEnumFactory(),
          false);
      composeEnumerationExtras("assurance", element.getAssuranceElement(),
          new Person.IdentityAssuranceLevelEnumFactory(), false);
    }
  }

  protected void composePractitioner(String name, Practitioner element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composePractitionerInner(element);
    }
  }

  protected void composePractitionerInner(Practitioner element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasActiveElement()) {
      composeBooleanCore("active", element.getActiveElement(), false);
      composeBooleanExtras("active", element.getActiveElement(), false);
    }
    if (element.hasName()) {
      composeHumanName("name", element.getName());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasAddress()) {
      openArray("address");
      for (Address e : element.getAddress())
        composeAddress(null, e);
      closeArray();
    }
    ;
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasBirthDateElement()) {
      composeDateCore("birthDate", element.getBirthDateElement(), false);
      composeDateExtras("birthDate", element.getBirthDateElement(), false);
    }
    if (element.hasPhoto()) {
      openArray("photo");
      for (Attachment e : element.getPhoto())
        composeAttachment(null, e);
      closeArray();
    }
    ;
    if (element.hasPractitionerRole()) {
      openArray("practitionerRole");
      for (Practitioner.PractitionerPractitionerRoleComponent e : element.getPractitionerRole())
        composePractitionerPractitionerPractitionerRoleComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasQualification()) {
      openArray("qualification");
      for (Practitioner.PractitionerQualificationComponent e : element.getQualification())
        composePractitionerPractitionerQualificationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCommunication()) {
      openArray("communication");
      for (CodeableConcept e : element.getCommunication())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
  }

  protected void composePractitionerPractitionerPractitionerRoleComponent(String name,
      Practitioner.PractitionerPractitionerRoleComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePractitionerPractitionerPractitionerRoleComponentInner(element);
      close();
    }
  }

  protected void composePractitionerPractitionerPractitionerRoleComponentInner(
      Practitioner.PractitionerPractitionerRoleComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasManagingOrganization()) {
      composeReference("managingOrganization", element.getManagingOrganization());
    }
    if (element.hasRole()) {
      composeCodeableConcept("role", element.getRole());
    }
    if (element.hasSpecialty()) {
      openArray("specialty");
      for (CodeableConcept e : element.getSpecialty())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasLocation()) {
      openArray("location");
      for (Reference e : element.getLocation())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasHealthcareService()) {
      openArray("healthcareService");
      for (Reference e : element.getHealthcareService())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composePractitionerPractitionerQualificationComponent(String name,
      Practitioner.PractitionerQualificationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composePractitionerPractitionerQualificationComponentInner(element);
      close();
    }
  }

  protected void composePractitionerPractitionerQualificationComponentInner(
      Practitioner.PractitionerQualificationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasIssuer()) {
      composeReference("issuer", element.getIssuer());
    }
  }

  protected void composeProcedure(String name, Procedure element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeProcedureInner(element);
    }
  }

  protected void composeProcedureInner(Procedure element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Procedure.ProcedureStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Procedure.ProcedureStatusEnumFactory(), false);
    }
    if (element.hasCategory()) {
      composeCodeableConcept("category", element.getCategory());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasNotPerformedElement()) {
      composeBooleanCore("notPerformed", element.getNotPerformedElement(), false);
      composeBooleanExtras("notPerformed", element.getNotPerformedElement(), false);
    }
    if (element.hasReasonNotPerformed()) {
      openArray("reasonNotPerformed");
      for (CodeableConcept e : element.getReasonNotPerformed())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasBodySite()) {
      openArray("bodySite");
      for (CodeableConcept e : element.getBodySite())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasPerformer()) {
      openArray("performer");
      for (Procedure.ProcedurePerformerComponent e : element.getPerformer())
        composeProcedureProcedurePerformerComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasPerformed()) {
      composeType("performed", element.getPerformed());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasOutcome()) {
      composeCodeableConcept("outcome", element.getOutcome());
    }
    if (element.hasReport()) {
      openArray("report");
      for (Reference e : element.getReport())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasComplication()) {
      openArray("complication");
      for (CodeableConcept e : element.getComplication())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasFollowUp()) {
      openArray("followUp");
      for (CodeableConcept e : element.getFollowUp())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasNotes()) {
      openArray("notes");
      for (Annotation e : element.getNotes())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasFocalDevice()) {
      openArray("focalDevice");
      for (Procedure.ProcedureFocalDeviceComponent e : element.getFocalDevice())
        composeProcedureProcedureFocalDeviceComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasUsed()) {
      openArray("used");
      for (Reference e : element.getUsed())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeProcedureProcedurePerformerComponent(String name, Procedure.ProcedurePerformerComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeProcedureProcedurePerformerComponentInner(element);
      close();
    }
  }

  protected void composeProcedureProcedurePerformerComponentInner(Procedure.ProcedurePerformerComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
    if (element.hasRole()) {
      composeCodeableConcept("role", element.getRole());
    }
  }

  protected void composeProcedureProcedureFocalDeviceComponent(String name,
      Procedure.ProcedureFocalDeviceComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeProcedureProcedureFocalDeviceComponentInner(element);
      close();
    }
  }

  protected void composeProcedureProcedureFocalDeviceComponentInner(Procedure.ProcedureFocalDeviceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasAction()) {
      composeCodeableConcept("action", element.getAction());
    }
    if (element.hasManipulated()) {
      composeReference("manipulated", element.getManipulated());
    }
  }

  protected void composeProcedureRequest(String name, ProcedureRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeProcedureRequestInner(element);
    }
  }

  protected void composeProcedureRequestInner(ProcedureRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasBodySite()) {
      openArray("bodySite");
      for (CodeableConcept e : element.getBodySite())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasScheduled()) {
      composeType("scheduled", element.getScheduled());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasPerformer()) {
      composeReference("performer", element.getPerformer());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new ProcedureRequest.ProcedureRequestStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new ProcedureRequest.ProcedureRequestStatusEnumFactory(), false);
    }
    if (element.hasNotes()) {
      openArray("notes");
      for (Annotation e : element.getNotes())
        composeAnnotation(null, e);
      closeArray();
    }
    ;
    if (element.hasAsNeeded()) {
      composeType("asNeeded", element.getAsNeeded());
    }
    if (element.hasOrderedOnElement()) {
      composeDateTimeCore("orderedOn", element.getOrderedOnElement(), false);
      composeDateTimeExtras("orderedOn", element.getOrderedOnElement(), false);
    }
    if (element.hasOrderer()) {
      composeReference("orderer", element.getOrderer());
    }
    if (element.hasPriorityElement()) {
      composeEnumerationCore("priority", element.getPriorityElement(),
          new ProcedureRequest.ProcedureRequestPriorityEnumFactory(), false);
      composeEnumerationExtras("priority", element.getPriorityElement(),
          new ProcedureRequest.ProcedureRequestPriorityEnumFactory(), false);
    }
  }

  protected void composeProcessRequest(String name, ProcessRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeProcessRequestInner(element);
    }
  }

  protected void composeProcessRequestInner(ProcessRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasActionElement()) {
      composeEnumerationCore("action", element.getActionElement(), new ProcessRequest.ActionListEnumFactory(), false);
      composeEnumerationExtras("action", element.getActionElement(), new ProcessRequest.ActionListEnumFactory(), false);
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasTarget()) {
      composeReference("target", element.getTarget());
    }
    if (element.hasProvider()) {
      composeReference("provider", element.getProvider());
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasResponse()) {
      composeReference("response", element.getResponse());
    }
    if (element.hasNullifyElement()) {
      composeBooleanCore("nullify", element.getNullifyElement(), false);
      composeBooleanExtras("nullify", element.getNullifyElement(), false);
    }
    if (element.hasReferenceElement()) {
      composeStringCore("reference", element.getReferenceElement(), false);
      composeStringExtras("reference", element.getReferenceElement(), false);
    }
    if (element.hasItem()) {
      openArray("item");
      for (ProcessRequest.ItemsComponent e : element.getItem())
        composeProcessRequestItemsComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasInclude()) {
      openArray("include");
      for (StringType e : element.getInclude())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getInclude())) {
        openArray("_include");
        for (StringType e : element.getInclude())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasExclude()) {
      openArray("exclude");
      for (StringType e : element.getExclude())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getExclude())) {
        openArray("_exclude");
        for (StringType e : element.getExclude())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeProcessRequestItemsComponent(String name, ProcessRequest.ItemsComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeProcessRequestItemsComponentInner(element);
      close();
    }
  }

  protected void composeProcessRequestItemsComponentInner(ProcessRequest.ItemsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSequenceLinkIdElement()) {
      composeIntegerCore("sequenceLinkId", element.getSequenceLinkIdElement(), false);
      composeIntegerExtras("sequenceLinkId", element.getSequenceLinkIdElement(), false);
    }
  }

  protected void composeProcessResponse(String name, ProcessResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeProcessResponseInner(element);
    }
  }

  protected void composeProcessResponseInner(ProcessResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasRequest()) {
      composeReference("request", element.getRequest());
    }
    if (element.hasOutcome()) {
      composeCoding("outcome", element.getOutcome());
    }
    if (element.hasDispositionElement()) {
      composeStringCore("disposition", element.getDispositionElement(), false);
      composeStringExtras("disposition", element.getDispositionElement(), false);
    }
    if (element.hasRuleset()) {
      composeCoding("ruleset", element.getRuleset());
    }
    if (element.hasOriginalRuleset()) {
      composeCoding("originalRuleset", element.getOriginalRuleset());
    }
    if (element.hasCreatedElement()) {
      composeDateTimeCore("created", element.getCreatedElement(), false);
      composeDateTimeExtras("created", element.getCreatedElement(), false);
    }
    if (element.hasOrganization()) {
      composeReference("organization", element.getOrganization());
    }
    if (element.hasRequestProvider()) {
      composeReference("requestProvider", element.getRequestProvider());
    }
    if (element.hasRequestOrganization()) {
      composeReference("requestOrganization", element.getRequestOrganization());
    }
    if (element.hasForm()) {
      composeCoding("form", element.getForm());
    }
    if (element.hasNotes()) {
      openArray("notes");
      for (ProcessResponse.ProcessResponseNotesComponent e : element.getNotes())
        composeProcessResponseProcessResponseNotesComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasError()) {
      openArray("error");
      for (Coding e : element.getError())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeProcessResponseProcessResponseNotesComponent(String name,
      ProcessResponse.ProcessResponseNotesComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeProcessResponseProcessResponseNotesComponentInner(element);
      close();
    }
  }

  protected void composeProcessResponseProcessResponseNotesComponentInner(
      ProcessResponse.ProcessResponseNotesComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
  }

  protected void composeProvenance(String name, Provenance element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeProvenanceInner(element);
    }
  }

  protected void composeProvenanceInner(Provenance element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasTarget()) {
      openArray("target");
      for (Reference e : element.getTarget())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
    if (element.hasRecordedElement()) {
      composeInstantCore("recorded", element.getRecordedElement(), false);
      composeInstantExtras("recorded", element.getRecordedElement(), false);
    }
    if (element.hasReason()) {
      openArray("reason");
      for (CodeableConcept e : element.getReason())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActivity()) {
      composeCodeableConcept("activity", element.getActivity());
    }
    if (element.hasLocation()) {
      composeReference("location", element.getLocation());
    }
    if (element.hasPolicy()) {
      openArray("policy");
      for (UriType e : element.getPolicy())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getPolicy())) {
        openArray("_policy");
        for (UriType e : element.getPolicy())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasAgent()) {
      openArray("agent");
      for (Provenance.ProvenanceAgentComponent e : element.getAgent())
        composeProvenanceProvenanceAgentComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasEntity()) {
      openArray("entity");
      for (Provenance.ProvenanceEntityComponent e : element.getEntity())
        composeProvenanceProvenanceEntityComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSignature()) {
      openArray("signature");
      for (Signature e : element.getSignature())
        composeSignature(null, e);
      closeArray();
    }
    ;
  }

  protected void composeProvenanceProvenanceAgentComponent(String name, Provenance.ProvenanceAgentComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeProvenanceProvenanceAgentComponentInner(element);
      close();
    }
  }

  protected void composeProvenanceProvenanceAgentComponentInner(Provenance.ProvenanceAgentComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasRole()) {
      composeCoding("role", element.getRole());
    }
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
    if (element.hasUserId()) {
      composeIdentifier("userId", element.getUserId());
    }
    if (element.hasRelatedAgent()) {
      openArray("relatedAgent");
      for (Provenance.ProvenanceAgentRelatedAgentComponent e : element.getRelatedAgent())
        composeProvenanceProvenanceAgentRelatedAgentComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeProvenanceProvenanceAgentRelatedAgentComponent(String name,
      Provenance.ProvenanceAgentRelatedAgentComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeProvenanceProvenanceAgentRelatedAgentComponentInner(element);
      close();
    }
  }

  protected void composeProvenanceProvenanceAgentRelatedAgentComponentInner(
      Provenance.ProvenanceAgentRelatedAgentComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasTargetElement()) {
      composeUriCore("target", element.getTargetElement(), false);
      composeUriExtras("target", element.getTargetElement(), false);
    }
  }

  protected void composeProvenanceProvenanceEntityComponent(String name, Provenance.ProvenanceEntityComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeProvenanceProvenanceEntityComponentInner(element);
      close();
    }
  }

  protected void composeProvenanceProvenanceEntityComponentInner(Provenance.ProvenanceEntityComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasRoleElement()) {
      composeEnumerationCore("role", element.getRoleElement(), new Provenance.ProvenanceEntityRoleEnumFactory(), false);
      composeEnumerationExtras("role", element.getRoleElement(), new Provenance.ProvenanceEntityRoleEnumFactory(),
          false);
    }
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasReferenceElement()) {
      composeUriCore("reference", element.getReferenceElement(), false);
      composeUriExtras("reference", element.getReferenceElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasAgent()) {
      composeProvenanceProvenanceAgentComponent("agent", element.getAgent());
    }
  }

  protected void composeQuestionnaire(String name, Questionnaire element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeQuestionnaireInner(element);
    }
  }

  protected void composeQuestionnaireInner(Questionnaire element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Questionnaire.QuestionnaireStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Questionnaire.QuestionnaireStatusEnumFactory(),
          false);
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasSubjectType()) {
      openArray("subjectType");
      for (CodeType e : element.getSubjectType())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getSubjectType())) {
        openArray("_subjectType");
        for (CodeType e : element.getSubjectType())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasGroup()) {
      composeQuestionnaireGroupComponent("group", element.getGroup());
    }
  }

  protected void composeQuestionnaireGroupComponent(String name, Questionnaire.GroupComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeQuestionnaireGroupComponentInner(element);
      close();
    }
  }

  protected void composeQuestionnaireGroupComponentInner(Questionnaire.GroupComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLinkIdElement()) {
      composeStringCore("linkId", element.getLinkIdElement(), false);
      composeStringExtras("linkId", element.getLinkIdElement(), false);
    }
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasConcept()) {
      openArray("concept");
      for (Coding e : element.getConcept())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasRequiredElement()) {
      composeBooleanCore("required", element.getRequiredElement(), false);
      composeBooleanExtras("required", element.getRequiredElement(), false);
    }
    if (element.hasRepeatsElement()) {
      composeBooleanCore("repeats", element.getRepeatsElement(), false);
      composeBooleanExtras("repeats", element.getRepeatsElement(), false);
    }
    if (element.hasGroup()) {
      openArray("group");
      for (Questionnaire.GroupComponent e : element.getGroup())
        composeQuestionnaireGroupComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasQuestion()) {
      openArray("question");
      for (Questionnaire.QuestionComponent e : element.getQuestion())
        composeQuestionnaireQuestionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeQuestionnaireQuestionComponent(String name, Questionnaire.QuestionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeQuestionnaireQuestionComponentInner(element);
      close();
    }
  }

  protected void composeQuestionnaireQuestionComponentInner(Questionnaire.QuestionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLinkIdElement()) {
      composeStringCore("linkId", element.getLinkIdElement(), false);
      composeStringExtras("linkId", element.getLinkIdElement(), false);
    }
    if (element.hasConcept()) {
      openArray("concept");
      for (Coding e : element.getConcept())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Questionnaire.AnswerFormatEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Questionnaire.AnswerFormatEnumFactory(), false);
    }
    if (element.hasRequiredElement()) {
      composeBooleanCore("required", element.getRequiredElement(), false);
      composeBooleanExtras("required", element.getRequiredElement(), false);
    }
    if (element.hasRepeatsElement()) {
      composeBooleanCore("repeats", element.getRepeatsElement(), false);
      composeBooleanExtras("repeats", element.getRepeatsElement(), false);
    }
    if (element.hasOptions()) {
      composeReference("options", element.getOptions());
    }
    if (element.hasOption()) {
      openArray("option");
      for (Coding e : element.getOption())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasGroup()) {
      openArray("group");
      for (Questionnaire.GroupComponent e : element.getGroup())
        composeQuestionnaireGroupComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeQuestionnaireResponse(String name, QuestionnaireResponse element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeQuestionnaireResponseInner(element);
    }
  }

  protected void composeQuestionnaireResponseInner(QuestionnaireResponse element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasQuestionnaire()) {
      composeReference("questionnaire", element.getQuestionnaire());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new QuestionnaireResponse.QuestionnaireResponseStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new QuestionnaireResponse.QuestionnaireResponseStatusEnumFactory(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasAuthor()) {
      composeReference("author", element.getAuthor());
    }
    if (element.hasAuthoredElement()) {
      composeDateTimeCore("authored", element.getAuthoredElement(), false);
      composeDateTimeExtras("authored", element.getAuthoredElement(), false);
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasGroup()) {
      composeQuestionnaireResponseGroupComponent("group", element.getGroup());
    }
  }

  protected void composeQuestionnaireResponseGroupComponent(String name, QuestionnaireResponse.GroupComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeQuestionnaireResponseGroupComponentInner(element);
      close();
    }
  }

  protected void composeQuestionnaireResponseGroupComponentInner(QuestionnaireResponse.GroupComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLinkIdElement()) {
      composeStringCore("linkId", element.getLinkIdElement(), false);
      composeStringExtras("linkId", element.getLinkIdElement(), false);
    }
    if (element.hasTitleElement()) {
      composeStringCore("title", element.getTitleElement(), false);
      composeStringExtras("title", element.getTitleElement(), false);
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasGroup()) {
      openArray("group");
      for (QuestionnaireResponse.GroupComponent e : element.getGroup())
        composeQuestionnaireResponseGroupComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasQuestion()) {
      openArray("question");
      for (QuestionnaireResponse.QuestionComponent e : element.getQuestion())
        composeQuestionnaireResponseQuestionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeQuestionnaireResponseQuestionComponent(String name,
      QuestionnaireResponse.QuestionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeQuestionnaireResponseQuestionComponentInner(element);
      close();
    }
  }

  protected void composeQuestionnaireResponseQuestionComponentInner(QuestionnaireResponse.QuestionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLinkIdElement()) {
      composeStringCore("linkId", element.getLinkIdElement(), false);
      composeStringExtras("linkId", element.getLinkIdElement(), false);
    }
    if (element.hasTextElement()) {
      composeStringCore("text", element.getTextElement(), false);
      composeStringExtras("text", element.getTextElement(), false);
    }
    if (element.hasAnswer()) {
      openArray("answer");
      for (QuestionnaireResponse.QuestionAnswerComponent e : element.getAnswer())
        composeQuestionnaireResponseQuestionAnswerComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeQuestionnaireResponseQuestionAnswerComponent(String name,
      QuestionnaireResponse.QuestionAnswerComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeQuestionnaireResponseQuestionAnswerComponentInner(element);
      close();
    }
  }

  protected void composeQuestionnaireResponseQuestionAnswerComponentInner(
      QuestionnaireResponse.QuestionAnswerComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
    if (element.hasGroup()) {
      openArray("group");
      for (QuestionnaireResponse.GroupComponent e : element.getGroup())
        composeQuestionnaireResponseGroupComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeReferralRequest(String name, ReferralRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeReferralRequestInner(element);
    }
  }

  protected void composeReferralRequestInner(ReferralRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new ReferralRequest.ReferralStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new ReferralRequest.ReferralStatusEnumFactory(),
          false);
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSpecialty()) {
      composeCodeableConcept("specialty", element.getSpecialty());
    }
    if (element.hasPriority()) {
      composeCodeableConcept("priority", element.getPriority());
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasRequester()) {
      composeReference("requester", element.getRequester());
    }
    if (element.hasRecipient()) {
      openArray("recipient");
      for (Reference e : element.getRecipient())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasDateSentElement()) {
      composeDateTimeCore("dateSent", element.getDateSentElement(), false);
      composeDateTimeExtras("dateSent", element.getDateSentElement(), false);
    }
    if (element.hasReason()) {
      composeCodeableConcept("reason", element.getReason());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasServiceRequested()) {
      openArray("serviceRequested");
      for (CodeableConcept e : element.getServiceRequested())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasSupportingInformation()) {
      openArray("supportingInformation");
      for (Reference e : element.getSupportingInformation())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasFulfillmentTime()) {
      composePeriod("fulfillmentTime", element.getFulfillmentTime());
    }
  }

  protected void composeRelatedPerson(String name, RelatedPerson element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeRelatedPersonInner(element);
    }
  }

  protected void composeRelatedPersonInner(RelatedPerson element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasRelationship()) {
      composeCodeableConcept("relationship", element.getRelationship());
    }
    if (element.hasName()) {
      composeHumanName("name", element.getName());
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasGenderElement()) {
      composeEnumerationCore("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
      composeEnumerationExtras("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory(),
          false);
    }
    if (element.hasBirthDateElement()) {
      composeDateCore("birthDate", element.getBirthDateElement(), false);
      composeDateExtras("birthDate", element.getBirthDateElement(), false);
    }
    if (element.hasAddress()) {
      openArray("address");
      for (Address e : element.getAddress())
        composeAddress(null, e);
      closeArray();
    }
    ;
    if (element.hasPhoto()) {
      openArray("photo");
      for (Attachment e : element.getPhoto())
        composeAttachment(null, e);
      closeArray();
    }
    ;
    if (element.hasPeriod()) {
      composePeriod("period", element.getPeriod());
    }
  }

  protected void composeRiskAssessment(String name, RiskAssessment element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeRiskAssessmentInner(element);
    }
  }

  protected void composeRiskAssessmentInner(RiskAssessment element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasCondition()) {
      composeReference("condition", element.getCondition());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasPerformer()) {
      composeReference("performer", element.getPerformer());
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasBasis()) {
      openArray("basis");
      for (Reference e : element.getBasis())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasPrediction()) {
      openArray("prediction");
      for (RiskAssessment.RiskAssessmentPredictionComponent e : element.getPrediction())
        composeRiskAssessmentRiskAssessmentPredictionComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasMitigationElement()) {
      composeStringCore("mitigation", element.getMitigationElement(), false);
      composeStringExtras("mitigation", element.getMitigationElement(), false);
    }
  }

  protected void composeRiskAssessmentRiskAssessmentPredictionComponent(String name,
      RiskAssessment.RiskAssessmentPredictionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeRiskAssessmentRiskAssessmentPredictionComponentInner(element);
      close();
    }
  }

  protected void composeRiskAssessmentRiskAssessmentPredictionComponentInner(
      RiskAssessment.RiskAssessmentPredictionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasOutcome()) {
      composeCodeableConcept("outcome", element.getOutcome());
    }
    if (element.hasProbability()) {
      composeType("probability", element.getProbability());
    }
    if (element.hasRelativeRiskElement()) {
      composeDecimalCore("relativeRisk", element.getRelativeRiskElement(), false);
      composeDecimalExtras("relativeRisk", element.getRelativeRiskElement(), false);
    }
    if (element.hasWhen()) {
      composeType("when", element.getWhen());
    }
    if (element.hasRationaleElement()) {
      composeStringCore("rationale", element.getRationaleElement(), false);
      composeStringExtras("rationale", element.getRationaleElement(), false);
    }
  }

  protected void composeSchedule(String name, Schedule element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeScheduleInner(element);
    }
  }

  protected void composeScheduleInner(Schedule element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      openArray("type");
      for (CodeableConcept e : element.getType())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasActor()) {
      composeReference("actor", element.getActor());
    }
    if (element.hasPlanningHorizon()) {
      composePeriod("planningHorizon", element.getPlanningHorizon());
    }
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
  }

  protected void composeSearchParameter(String name, SearchParameter element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSearchParameterInner(element);
    }
  }

  protected void composeSearchParameterInner(SearchParameter element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (SearchParameter.SearchParameterContactComponent e : element.getContact())
        composeSearchParameterSearchParameterContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasBaseElement()) {
      composeCodeCore("base", element.getBaseElement(), false);
      composeCodeExtras("base", element.getBaseElement(), false);
    }
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory(), false);
      composeEnumerationExtras("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasXpathElement()) {
      composeStringCore("xpath", element.getXpathElement(), false);
      composeStringExtras("xpath", element.getXpathElement(), false);
    }
    if (element.hasXpathUsageElement()) {
      composeEnumerationCore("xpathUsage", element.getXpathUsageElement(),
          new SearchParameter.XPathUsageTypeEnumFactory(), false);
      composeEnumerationExtras("xpathUsage", element.getXpathUsageElement(),
          new SearchParameter.XPathUsageTypeEnumFactory(), false);
    }
    if (element.hasTarget()) {
      openArray("target");
      for (CodeType e : element.getTarget())
        composeCodeCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getTarget())) {
        openArray("_target");
        for (CodeType e : element.getTarget())
          composeCodeExtras(null, e, true);
        closeArray();
      }
    }
    ;
  }

  protected void composeSearchParameterSearchParameterContactComponent(String name,
      SearchParameter.SearchParameterContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeSearchParameterSearchParameterContactComponentInner(element);
      close();
    }
  }

  protected void composeSearchParameterSearchParameterContactComponentInner(
      SearchParameter.SearchParameterContactComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSlot(String name, Slot element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSlotInner(element);
    }
  }

  protected void composeSlotInner(Slot element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasSchedule()) {
      composeReference("schedule", element.getSchedule());
    }
    if (element.hasFreeBusyTypeElement()) {
      composeEnumerationCore("freeBusyType", element.getFreeBusyTypeElement(), new Slot.SlotStatusEnumFactory(), false);
      composeEnumerationExtras("freeBusyType", element.getFreeBusyTypeElement(), new Slot.SlotStatusEnumFactory(),
          false);
    }
    if (element.hasStartElement()) {
      composeInstantCore("start", element.getStartElement(), false);
      composeInstantExtras("start", element.getStartElement(), false);
    }
    if (element.hasEndElement()) {
      composeInstantCore("end", element.getEndElement(), false);
      composeInstantExtras("end", element.getEndElement(), false);
    }
    if (element.hasOverbookedElement()) {
      composeBooleanCore("overbooked", element.getOverbookedElement(), false);
      composeBooleanExtras("overbooked", element.getOverbookedElement(), false);
    }
    if (element.hasCommentElement()) {
      composeStringCore("comment", element.getCommentElement(), false);
      composeStringExtras("comment", element.getCommentElement(), false);
    }
  }

  protected void composeSpecimen(String name, Specimen element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSpecimenInner(element);
    }
  }

  protected void composeSpecimenInner(Specimen element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Specimen.SpecimenStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(), new Specimen.SpecimenStatusEnumFactory(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasParent()) {
      openArray("parent");
      for (Reference e : element.getParent())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasSubject()) {
      composeReference("subject", element.getSubject());
    }
    if (element.hasAccessionIdentifier()) {
      composeIdentifier("accessionIdentifier", element.getAccessionIdentifier());
    }
    if (element.hasReceivedTimeElement()) {
      composeDateTimeCore("receivedTime", element.getReceivedTimeElement(), false);
      composeDateTimeExtras("receivedTime", element.getReceivedTimeElement(), false);
    }
    if (element.hasCollection()) {
      composeSpecimenSpecimenCollectionComponent("collection", element.getCollection());
    }
    if (element.hasTreatment()) {
      openArray("treatment");
      for (Specimen.SpecimenTreatmentComponent e : element.getTreatment())
        composeSpecimenSpecimenTreatmentComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasContainer()) {
      openArray("container");
      for (Specimen.SpecimenContainerComponent e : element.getContainer())
        composeSpecimenSpecimenContainerComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSpecimenSpecimenCollectionComponent(String name, Specimen.SpecimenCollectionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeSpecimenSpecimenCollectionComponentInner(element);
      close();
    }
  }

  protected void composeSpecimenSpecimenCollectionComponentInner(Specimen.SpecimenCollectionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCollector()) {
      composeReference("collector", element.getCollector());
    }
    if (element.hasComment()) {
      openArray("comment");
      for (StringType e : element.getComment())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getComment())) {
        openArray("_comment");
        for (StringType e : element.getComment())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasCollected()) {
      composeType("collected", element.getCollected());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasMethod()) {
      composeCodeableConcept("method", element.getMethod());
    }
    if (element.hasBodySite()) {
      composeCodeableConcept("bodySite", element.getBodySite());
    }
  }

  protected void composeSpecimenSpecimenTreatmentComponent(String name, Specimen.SpecimenTreatmentComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeSpecimenSpecimenTreatmentComponentInner(element);
      close();
    }
  }

  protected void composeSpecimenSpecimenTreatmentComponentInner(Specimen.SpecimenTreatmentComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasProcedure()) {
      composeCodeableConcept("procedure", element.getProcedure());
    }
    if (element.hasAdditive()) {
      openArray("additive");
      for (Reference e : element.getAdditive())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSpecimenSpecimenContainerComponent(String name, Specimen.SpecimenContainerComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeSpecimenSpecimenContainerComponentInner(element);
      close();
    }
  }

  protected void composeSpecimenSpecimenContainerComponentInner(Specimen.SpecimenContainerComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasCapacity()) {
      composeSimpleQuantity("capacity", element.getCapacity());
    }
    if (element.hasSpecimenQuantity()) {
      composeSimpleQuantity("specimenQuantity", element.getSpecimenQuantity());
    }
    if (element.hasAdditive()) {
      composeType("additive", element.getAdditive());
    }
  }

  protected void composeStructureDefinition(String name, StructureDefinition element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeStructureDefinitionInner(element);
    }
  }

  protected void composeStructureDefinitionInner(StructureDefinition element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (StructureDefinition.StructureDefinitionContactComponent e : element.getContact())
        composeStructureDefinitionStructureDefinitionContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasCode()) {
      openArray("code");
      for (Coding e : element.getCode())
        composeCoding(null, e);
      closeArray();
    }
    ;
    if (element.hasFhirVersionElement()) {
      composeIdCore("fhirVersion", element.getFhirVersionElement(), false);
      composeIdExtras("fhirVersion", element.getFhirVersionElement(), false);
    }
    if (element.hasMapping()) {
      openArray("mapping");
      for (StructureDefinition.StructureDefinitionMappingComponent e : element.getMapping())
        composeStructureDefinitionStructureDefinitionMappingComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasKindElement()) {
      composeEnumerationCore("kind", element.getKindElement(),
          new StructureDefinition.StructureDefinitionKindEnumFactory(), false);
      composeEnumerationExtras("kind", element.getKindElement(),
          new StructureDefinition.StructureDefinitionKindEnumFactory(), false);
    }
    if (element.hasConstrainedTypeElement()) {
      composeCodeCore("constrainedType", element.getConstrainedTypeElement(), false);
      composeCodeExtras("constrainedType", element.getConstrainedTypeElement(), false);
    }
    if (element.hasAbstractElement()) {
      composeBooleanCore("abstract", element.getAbstractElement(), false);
      composeBooleanExtras("abstract", element.getAbstractElement(), false);
    }
    if (element.hasContextTypeElement()) {
      composeEnumerationCore("contextType", element.getContextTypeElement(),
          new StructureDefinition.ExtensionContextEnumFactory(), false);
      composeEnumerationExtras("contextType", element.getContextTypeElement(),
          new StructureDefinition.ExtensionContextEnumFactory(), false);
    }
    if (element.hasContext()) {
      openArray("context");
      for (StringType e : element.getContext())
        composeStringCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getContext())) {
        openArray("_context");
        for (StringType e : element.getContext())
          composeStringExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasBaseElement()) {
      composeUriCore("base", element.getBaseElement(), false);
      composeUriExtras("base", element.getBaseElement(), false);
    }
    if (element.hasSnapshot()) {
      composeStructureDefinitionStructureDefinitionSnapshotComponent("snapshot", element.getSnapshot());
    }
    if (element.hasDifferential()) {
      composeStructureDefinitionStructureDefinitionDifferentialComponent("differential", element.getDifferential());
    }
  }

  protected void composeStructureDefinitionStructureDefinitionContactComponent(String name,
      StructureDefinition.StructureDefinitionContactComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeStructureDefinitionStructureDefinitionContactComponentInner(element);
      close();
    }
  }

  protected void composeStructureDefinitionStructureDefinitionContactComponentInner(
      StructureDefinition.StructureDefinitionContactComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeStructureDefinitionStructureDefinitionMappingComponent(String name,
      StructureDefinition.StructureDefinitionMappingComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeStructureDefinitionStructureDefinitionMappingComponentInner(element);
      close();
    }
  }

  protected void composeStructureDefinitionStructureDefinitionMappingComponentInner(
      StructureDefinition.StructureDefinitionMappingComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasIdentityElement()) {
      composeIdCore("identity", element.getIdentityElement(), false);
      composeIdExtras("identity", element.getIdentityElement(), false);
    }
    if (element.hasUriElement()) {
      composeUriCore("uri", element.getUriElement(), false);
      composeUriExtras("uri", element.getUriElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasCommentsElement()) {
      composeStringCore("comments", element.getCommentsElement(), false);
      composeStringExtras("comments", element.getCommentsElement(), false);
    }
  }

  protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(String name,
      StructureDefinition.StructureDefinitionSnapshotComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeStructureDefinitionStructureDefinitionSnapshotComponentInner(element);
      close();
    }
  }

  protected void composeStructureDefinitionStructureDefinitionSnapshotComponentInner(
      StructureDefinition.StructureDefinitionSnapshotComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasElement()) {
      openArray("element");
      for (ElementDefinition e : element.getElement())
        composeElementDefinition(null, e);
      closeArray();
    }
    ;
  }

  protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(String name,
      StructureDefinition.StructureDefinitionDifferentialComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeStructureDefinitionStructureDefinitionDifferentialComponentInner(element);
      close();
    }
  }

  protected void composeStructureDefinitionStructureDefinitionDifferentialComponentInner(
      StructureDefinition.StructureDefinitionDifferentialComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasElement()) {
      openArray("element");
      for (ElementDefinition e : element.getElement())
        composeElementDefinition(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSubscription(String name, Subscription element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSubscriptionInner(element);
    }
  }

  protected void composeSubscriptionInner(Subscription element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasCriteriaElement()) {
      composeStringCore("criteria", element.getCriteriaElement(), false);
      composeStringExtras("criteria", element.getCriteriaElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (ContactPoint e : element.getContact())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
    if (element.hasReasonElement()) {
      composeStringCore("reason", element.getReasonElement(), false);
      composeStringExtras("reason", element.getReasonElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new Subscription.SubscriptionStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new Subscription.SubscriptionStatusEnumFactory(),
          false);
    }
    if (element.hasErrorElement()) {
      composeStringCore("error", element.getErrorElement(), false);
      composeStringExtras("error", element.getErrorElement(), false);
    }
    if (element.hasChannel()) {
      composeSubscriptionSubscriptionChannelComponent("channel", element.getChannel());
    }
    if (element.hasEndElement()) {
      composeInstantCore("end", element.getEndElement(), false);
      composeInstantExtras("end", element.getEndElement(), false);
    }
    if (element.hasTag()) {
      openArray("tag");
      for (Coding e : element.getTag())
        composeCoding(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSubscriptionSubscriptionChannelComponent(String name,
      Subscription.SubscriptionChannelComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeSubscriptionSubscriptionChannelComponentInner(element);
      close();
    }
  }

  protected void composeSubscriptionSubscriptionChannelComponentInner(Subscription.SubscriptionChannelComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasTypeElement()) {
      composeEnumerationCore("type", element.getTypeElement(), new Subscription.SubscriptionChannelTypeEnumFactory(),
          false);
      composeEnumerationExtras("type", element.getTypeElement(), new Subscription.SubscriptionChannelTypeEnumFactory(),
          false);
    }
    if (element.hasEndpointElement()) {
      composeUriCore("endpoint", element.getEndpointElement(), false);
      composeUriExtras("endpoint", element.getEndpointElement(), false);
    }
    if (element.hasPayloadElement()) {
      composeStringCore("payload", element.getPayloadElement(), false);
      composeStringExtras("payload", element.getPayloadElement(), false);
    }
    if (element.hasHeaderElement()) {
      composeStringCore("header", element.getHeaderElement(), false);
      composeStringExtras("header", element.getHeaderElement(), false);
    }
  }

  protected void composeSubstance(String name, Substance element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSubstanceInner(element);
    }
  }

  protected void composeSubstanceInner(Substance element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasCategory()) {
      openArray("category");
      for (CodeableConcept e : element.getCategory())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasInstance()) {
      openArray("instance");
      for (Substance.SubstanceInstanceComponent e : element.getInstance())
        composeSubstanceSubstanceInstanceComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasIngredient()) {
      openArray("ingredient");
      for (Substance.SubstanceIngredientComponent e : element.getIngredient())
        composeSubstanceSubstanceIngredientComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSubstanceSubstanceInstanceComponent(String name, Substance.SubstanceInstanceComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeSubstanceSubstanceInstanceComponentInner(element);
      close();
    }
  }

  protected void composeSubstanceSubstanceInstanceComponentInner(Substance.SubstanceInstanceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasExpiryElement()) {
      composeDateTimeCore("expiry", element.getExpiryElement(), false);
      composeDateTimeExtras("expiry", element.getExpiryElement(), false);
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
  }

  protected void composeSubstanceSubstanceIngredientComponent(String name,
      Substance.SubstanceIngredientComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeSubstanceSubstanceIngredientComponentInner(element);
      close();
    }
  }

  protected void composeSubstanceSubstanceIngredientComponentInner(Substance.SubstanceIngredientComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasQuantity()) {
      composeRatio("quantity", element.getQuantity());
    }
    if (element.hasSubstance()) {
      composeReference("substance", element.getSubstance());
    }
  }

  protected void composeSupplyDelivery(String name, SupplyDelivery element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSupplyDeliveryInner(element);
    }
  }

  protected void composeSupplyDeliveryInner(SupplyDelivery element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new SupplyDelivery.SupplyDeliveryStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new SupplyDelivery.SupplyDeliveryStatusEnumFactory(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasType()) {
      composeCodeableConcept("type", element.getType());
    }
    if (element.hasQuantity()) {
      composeSimpleQuantity("quantity", element.getQuantity());
    }
    if (element.hasSuppliedItem()) {
      composeReference("suppliedItem", element.getSuppliedItem());
    }
    if (element.hasSupplier()) {
      composeReference("supplier", element.getSupplier());
    }
    if (element.hasWhenPrepared()) {
      composePeriod("whenPrepared", element.getWhenPrepared());
    }
    if (element.hasTimeElement()) {
      composeDateTimeCore("time", element.getTimeElement(), false);
      composeDateTimeExtras("time", element.getTimeElement(), false);
    }
    if (element.hasDestination()) {
      composeReference("destination", element.getDestination());
    }
    if (element.hasReceiver()) {
      openArray("receiver");
      for (Reference e : element.getReceiver())
        composeReference(null, e);
      closeArray();
    }
    ;
  }

  protected void composeSupplyRequest(String name, SupplyRequest element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeSupplyRequestInner(element);
    }
  }

  protected void composeSupplyRequestInner(SupplyRequest element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasSource()) {
      composeReference("source", element.getSource());
    }
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(), new SupplyRequest.SupplyRequestStatusEnumFactory(),
          false);
      composeEnumerationExtras("status", element.getStatusElement(), new SupplyRequest.SupplyRequestStatusEnumFactory(),
          false);
    }
    if (element.hasKind()) {
      composeCodeableConcept("kind", element.getKind());
    }
    if (element.hasOrderedItem()) {
      composeReference("orderedItem", element.getOrderedItem());
    }
    if (element.hasSupplier()) {
      openArray("supplier");
      for (Reference e : element.getSupplier())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasWhen()) {
      composeSupplyRequestSupplyRequestWhenComponent("when", element.getWhen());
    }
  }

  protected void composeSupplyRequestSupplyRequestWhenComponent(String name,
      SupplyRequest.SupplyRequestWhenComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeSupplyRequestSupplyRequestWhenComponentInner(element);
      close();
    }
  }

  protected void composeSupplyRequestSupplyRequestWhenComponentInner(SupplyRequest.SupplyRequestWhenComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCode()) {
      composeCodeableConcept("code", element.getCode());
    }
    if (element.hasSchedule()) {
      composeTiming("schedule", element.getSchedule());
    }
  }

  protected void composeTestScript(String name, TestScript element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeTestScriptInner(element);
    }
  }

  protected void composeTestScriptInner(TestScript element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (TestScript.TestScriptContactComponent e : element.getContact())
        composeTestScriptTestScriptContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasMetadata()) {
      composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
    }
    if (element.hasMultiserverElement()) {
      composeBooleanCore("multiserver", element.getMultiserverElement(), false);
      composeBooleanExtras("multiserver", element.getMultiserverElement(), false);
    }
    if (element.hasFixture()) {
      openArray("fixture");
      for (TestScript.TestScriptFixtureComponent e : element.getFixture())
        composeTestScriptTestScriptFixtureComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasProfile()) {
      openArray("profile");
      for (Reference e : element.getProfile())
        composeReference(null, e);
      closeArray();
    }
    ;
    if (element.hasVariable()) {
      openArray("variable");
      for (TestScript.TestScriptVariableComponent e : element.getVariable())
        composeTestScriptTestScriptVariableComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasSetup()) {
      composeTestScriptTestScriptSetupComponent("setup", element.getSetup());
    }
    if (element.hasTest()) {
      openArray("test");
      for (TestScript.TestScriptTestComponent e : element.getTest())
        composeTestScriptTestScriptTestComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasTeardown()) {
      composeTestScriptTestScriptTeardownComponent("teardown", element.getTeardown());
    }
  }

  protected void composeTestScriptTestScriptContactComponent(String name, TestScript.TestScriptContactComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptContactComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptContactComponentInner(TestScript.TestScriptContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeTestScriptTestScriptMetadataComponent(String name,
      TestScript.TestScriptMetadataComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptMetadataComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptMetadataComponentInner(TestScript.TestScriptMetadataComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasLink()) {
      openArray("link");
      for (TestScript.TestScriptMetadataLinkComponent e : element.getLink())
        composeTestScriptTestScriptMetadataLinkComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasCapability()) {
      openArray("capability");
      for (TestScript.TestScriptMetadataCapabilityComponent e : element.getCapability())
        composeTestScriptTestScriptMetadataCapabilityComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeTestScriptTestScriptMetadataLinkComponent(String name,
      TestScript.TestScriptMetadataLinkComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptMetadataLinkComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptMetadataLinkComponentInner(
      TestScript.TestScriptMetadataLinkComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
  }

  protected void composeTestScriptTestScriptMetadataCapabilityComponent(String name,
      TestScript.TestScriptMetadataCapabilityComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptMetadataCapabilityComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptMetadataCapabilityComponentInner(
      TestScript.TestScriptMetadataCapabilityComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasRequiredElement()) {
      composeBooleanCore("required", element.getRequiredElement(), false);
      composeBooleanExtras("required", element.getRequiredElement(), false);
    }
    if (element.hasValidatedElement()) {
      composeBooleanCore("validated", element.getValidatedElement(), false);
      composeBooleanExtras("validated", element.getValidatedElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasDestinationElement()) {
      composeIntegerCore("destination", element.getDestinationElement(), false);
      composeIntegerExtras("destination", element.getDestinationElement(), false);
    }
    if (element.hasLink()) {
      openArray("link");
      for (UriType e : element.getLink())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getLink())) {
        openArray("_link");
        for (UriType e : element.getLink())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasConformance()) {
      composeReference("conformance", element.getConformance());
    }
  }

  protected void composeTestScriptTestScriptFixtureComponent(String name, TestScript.TestScriptFixtureComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptFixtureComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptFixtureComponentInner(TestScript.TestScriptFixtureComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasAutocreateElement()) {
      composeBooleanCore("autocreate", element.getAutocreateElement(), false);
      composeBooleanExtras("autocreate", element.getAutocreateElement(), false);
    }
    if (element.hasAutodeleteElement()) {
      composeBooleanCore("autodelete", element.getAutodeleteElement(), false);
      composeBooleanExtras("autodelete", element.getAutodeleteElement(), false);
    }
    if (element.hasResource()) {
      composeReference("resource", element.getResource());
    }
  }

  protected void composeTestScriptTestScriptVariableComponent(String name,
      TestScript.TestScriptVariableComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptVariableComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptVariableComponentInner(TestScript.TestScriptVariableComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasHeaderFieldElement()) {
      composeStringCore("headerField", element.getHeaderFieldElement(), false);
      composeStringExtras("headerField", element.getHeaderFieldElement(), false);
    }
    if (element.hasPathElement()) {
      composeStringCore("path", element.getPathElement(), false);
      composeStringExtras("path", element.getPathElement(), false);
    }
    if (element.hasSourceIdElement()) {
      composeIdCore("sourceId", element.getSourceIdElement(), false);
      composeIdExtras("sourceId", element.getSourceIdElement(), false);
    }
  }

  protected void composeTestScriptTestScriptSetupComponent(String name, TestScript.TestScriptSetupComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptSetupComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptSetupComponentInner(TestScript.TestScriptSetupComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasMetadata()) {
      composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
    }
    if (element.hasAction()) {
      openArray("action");
      for (TestScript.TestScriptSetupActionComponent e : element.getAction())
        composeTestScriptTestScriptSetupActionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeTestScriptTestScriptSetupActionComponent(String name,
      TestScript.TestScriptSetupActionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptSetupActionComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptSetupActionComponentInner(TestScript.TestScriptSetupActionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasOperation()) {
      composeTestScriptTestScriptSetupActionOperationComponent("operation", element.getOperation());
    }
    if (element.hasAssert()) {
      composeTestScriptTestScriptSetupActionAssertComponent("assert", element.getAssert());
    }
  }

  protected void composeTestScriptTestScriptSetupActionOperationComponent(String name,
      TestScript.TestScriptSetupActionOperationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptSetupActionOperationComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptSetupActionOperationComponentInner(
      TestScript.TestScriptSetupActionOperationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasType()) {
      composeCoding("type", element.getType());
    }
    if (element.hasResourceElement()) {
      composeCodeCore("resource", element.getResourceElement(), false);
      composeCodeExtras("resource", element.getResourceElement(), false);
    }
    if (element.hasLabelElement()) {
      composeStringCore("label", element.getLabelElement(), false);
      composeStringExtras("label", element.getLabelElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasAcceptElement()) {
      composeEnumerationCore("accept", element.getAcceptElement(), new TestScript.ContentTypeEnumFactory(), false);
      composeEnumerationExtras("accept", element.getAcceptElement(), new TestScript.ContentTypeEnumFactory(), false);
    }
    if (element.hasContentTypeElement()) {
      composeEnumerationCore("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory(),
          false);
      composeEnumerationExtras("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory(),
          false);
    }
    if (element.hasDestinationElement()) {
      composeIntegerCore("destination", element.getDestinationElement(), false);
      composeIntegerExtras("destination", element.getDestinationElement(), false);
    }
    if (element.hasEncodeRequestUrlElement()) {
      composeBooleanCore("encodeRequestUrl", element.getEncodeRequestUrlElement(), false);
      composeBooleanExtras("encodeRequestUrl", element.getEncodeRequestUrlElement(), false);
    }
    if (element.hasParamsElement()) {
      composeStringCore("params", element.getParamsElement(), false);
      composeStringExtras("params", element.getParamsElement(), false);
    }
    if (element.hasRequestHeader()) {
      openArray("requestHeader");
      for (TestScript.TestScriptSetupActionOperationRequestHeaderComponent e : element.getRequestHeader())
        composeTestScriptTestScriptSetupActionOperationRequestHeaderComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasResponseIdElement()) {
      composeIdCore("responseId", element.getResponseIdElement(), false);
      composeIdExtras("responseId", element.getResponseIdElement(), false);
    }
    if (element.hasSourceIdElement()) {
      composeIdCore("sourceId", element.getSourceIdElement(), false);
      composeIdExtras("sourceId", element.getSourceIdElement(), false);
    }
    if (element.hasTargetIdElement()) {
      composeIdCore("targetId", element.getTargetIdElement(), false);
      composeIdExtras("targetId", element.getTargetIdElement(), false);
    }
    if (element.hasUrlElement()) {
      composeStringCore("url", element.getUrlElement(), false);
      composeStringExtras("url", element.getUrlElement(), false);
    }
  }

  protected void composeTestScriptTestScriptSetupActionOperationRequestHeaderComponent(String name,
      TestScript.TestScriptSetupActionOperationRequestHeaderComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptSetupActionOperationRequestHeaderComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptSetupActionOperationRequestHeaderComponentInner(
      TestScript.TestScriptSetupActionOperationRequestHeaderComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasFieldElement()) {
      composeStringCore("field", element.getFieldElement(), false);
      composeStringExtras("field", element.getFieldElement(), false);
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeTestScriptTestScriptSetupActionAssertComponent(String name,
      TestScript.TestScriptSetupActionAssertComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptSetupActionAssertComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptSetupActionAssertComponentInner(
      TestScript.TestScriptSetupActionAssertComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLabelElement()) {
      composeStringCore("label", element.getLabelElement(), false);
      composeStringExtras("label", element.getLabelElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasDirectionElement()) {
      composeEnumerationCore("direction", element.getDirectionElement(),
          new TestScript.AssertionDirectionTypeEnumFactory(), false);
      composeEnumerationExtras("direction", element.getDirectionElement(),
          new TestScript.AssertionDirectionTypeEnumFactory(), false);
    }
    if (element.hasCompareToSourceIdElement()) {
      composeStringCore("compareToSourceId", element.getCompareToSourceIdElement(), false);
      composeStringExtras("compareToSourceId", element.getCompareToSourceIdElement(), false);
    }
    if (element.hasCompareToSourcePathElement()) {
      composeStringCore("compareToSourcePath", element.getCompareToSourcePathElement(), false);
      composeStringExtras("compareToSourcePath", element.getCompareToSourcePathElement(), false);
    }
    if (element.hasContentTypeElement()) {
      composeEnumerationCore("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory(),
          false);
      composeEnumerationExtras("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory(),
          false);
    }
    if (element.hasHeaderFieldElement()) {
      composeStringCore("headerField", element.getHeaderFieldElement(), false);
      composeStringExtras("headerField", element.getHeaderFieldElement(), false);
    }
    if (element.hasMinimumIdElement()) {
      composeStringCore("minimumId", element.getMinimumIdElement(), false);
      composeStringExtras("minimumId", element.getMinimumIdElement(), false);
    }
    if (element.hasNavigationLinksElement()) {
      composeBooleanCore("navigationLinks", element.getNavigationLinksElement(), false);
      composeBooleanExtras("navigationLinks", element.getNavigationLinksElement(), false);
    }
    if (element.hasOperatorElement()) {
      composeEnumerationCore("operator", element.getOperatorElement(),
          new TestScript.AssertionOperatorTypeEnumFactory(), false);
      composeEnumerationExtras("operator", element.getOperatorElement(),
          new TestScript.AssertionOperatorTypeEnumFactory(), false);
    }
    if (element.hasPathElement()) {
      composeStringCore("path", element.getPathElement(), false);
      composeStringExtras("path", element.getPathElement(), false);
    }
    if (element.hasResourceElement()) {
      composeCodeCore("resource", element.getResourceElement(), false);
      composeCodeExtras("resource", element.getResourceElement(), false);
    }
    if (element.hasResponseElement()) {
      composeEnumerationCore("response", element.getResponseElement(),
          new TestScript.AssertionResponseTypesEnumFactory(), false);
      composeEnumerationExtras("response", element.getResponseElement(),
          new TestScript.AssertionResponseTypesEnumFactory(), false);
    }
    if (element.hasResponseCodeElement()) {
      composeStringCore("responseCode", element.getResponseCodeElement(), false);
      composeStringExtras("responseCode", element.getResponseCodeElement(), false);
    }
    if (element.hasSourceIdElement()) {
      composeIdCore("sourceId", element.getSourceIdElement(), false);
      composeIdExtras("sourceId", element.getSourceIdElement(), false);
    }
    if (element.hasValidateProfileIdElement()) {
      composeIdCore("validateProfileId", element.getValidateProfileIdElement(), false);
      composeIdExtras("validateProfileId", element.getValidateProfileIdElement(), false);
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
    if (element.hasWarningOnlyElement()) {
      composeBooleanCore("warningOnly", element.getWarningOnlyElement(), false);
      composeBooleanExtras("warningOnly", element.getWarningOnlyElement(), false);
    }
  }

  protected void composeTestScriptTestScriptTestComponent(String name, TestScript.TestScriptTestComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptTestComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptTestComponentInner(TestScript.TestScriptTestComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasMetadata()) {
      composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
    }
    if (element.hasAction()) {
      openArray("action");
      for (TestScript.TestScriptTestActionComponent e : element.getAction())
        composeTestScriptTestScriptTestActionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeTestScriptTestScriptTestActionComponent(String name,
      TestScript.TestScriptTestActionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptTestActionComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptTestActionComponentInner(TestScript.TestScriptTestActionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasOperation()) {
      composeTestScriptTestScriptSetupActionOperationComponent("operation", element.getOperation());
    }
    if (element.hasAssert()) {
      composeTestScriptTestScriptSetupActionAssertComponent("assert", element.getAssert());
    }
  }

  protected void composeTestScriptTestScriptTeardownComponent(String name,
      TestScript.TestScriptTeardownComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptTeardownComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptTeardownComponentInner(TestScript.TestScriptTeardownComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasAction()) {
      openArray("action");
      for (TestScript.TestScriptTeardownActionComponent e : element.getAction())
        composeTestScriptTestScriptTeardownActionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeTestScriptTestScriptTeardownActionComponent(String name,
      TestScript.TestScriptTeardownActionComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeTestScriptTestScriptTeardownActionComponentInner(element);
      close();
    }
  }

  protected void composeTestScriptTestScriptTeardownActionComponentInner(
      TestScript.TestScriptTeardownActionComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasOperation()) {
      composeTestScriptTestScriptSetupActionOperationComponent("operation", element.getOperation());
    }
  }

  protected void composeValueSet(String name, ValueSet element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeValueSetInner(element);
    }
  }

  protected void composeValueSetInner(ValueSet element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasUrlElement()) {
      composeUriCore("url", element.getUrlElement(), false);
      composeUriExtras("url", element.getUrlElement(), false);
    }
    if (element.hasIdentifier()) {
      composeIdentifier("identifier", element.getIdentifier());
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasStatusElement()) {
      composeEnumerationCore("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
      composeEnumerationExtras("status", element.getStatusElement(),
          new Enumerations.ConformanceResourceStatusEnumFactory(), false);
    }
    if (element.hasExperimentalElement()) {
      composeBooleanCore("experimental", element.getExperimentalElement(), false);
      composeBooleanExtras("experimental", element.getExperimentalElement(), false);
    }
    if (element.hasPublisherElement()) {
      composeStringCore("publisher", element.getPublisherElement(), false);
      composeStringExtras("publisher", element.getPublisherElement(), false);
    }
    if (element.hasContact()) {
      openArray("contact");
      for (ValueSet.ValueSetContactComponent e : element.getContact())
        composeValueSetValueSetContactComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasDateElement()) {
      composeDateTimeCore("date", element.getDateElement(), false);
      composeDateTimeExtras("date", element.getDateElement(), false);
    }
    if (element.hasLockedDateElement()) {
      composeDateCore("lockedDate", element.getLockedDateElement(), false);
      composeDateExtras("lockedDate", element.getLockedDateElement(), false);
    }
    if (element.hasDescriptionElement()) {
      composeStringCore("description", element.getDescriptionElement(), false);
      composeStringExtras("description", element.getDescriptionElement(), false);
    }
    if (element.hasUseContext()) {
      openArray("useContext");
      for (CodeableConcept e : element.getUseContext())
        composeCodeableConcept(null, e);
      closeArray();
    }
    ;
    if (element.hasImmutableElement()) {
      composeBooleanCore("immutable", element.getImmutableElement(), false);
      composeBooleanExtras("immutable", element.getImmutableElement(), false);
    }
    if (element.hasRequirementsElement()) {
      composeStringCore("requirements", element.getRequirementsElement(), false);
      composeStringExtras("requirements", element.getRequirementsElement(), false);
    }
    if (element.hasCopyrightElement()) {
      composeStringCore("copyright", element.getCopyrightElement(), false);
      composeStringExtras("copyright", element.getCopyrightElement(), false);
    }
    if (element.hasExtensibleElement()) {
      composeBooleanCore("extensible", element.getExtensibleElement(), false);
      composeBooleanExtras("extensible", element.getExtensibleElement(), false);
    }
    if (element.hasCodeSystem()) {
      composeValueSetValueSetCodeSystemComponent("codeSystem", element.getCodeSystem());
    }
    if (element.hasCompose()) {
      composeValueSetValueSetComposeComponent("compose", element.getCompose());
    }
    if (element.hasExpansion()) {
      composeValueSetValueSetExpansionComponent("expansion", element.getExpansion());
    }
  }

  protected void composeValueSetValueSetContactComponent(String name, ValueSet.ValueSetContactComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetContactComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetContactComponentInner(ValueSet.ValueSetContactComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasTelecom()) {
      openArray("telecom");
      for (ContactPoint e : element.getTelecom())
        composeContactPoint(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetValueSetCodeSystemComponent(String name, ValueSet.ValueSetCodeSystemComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetCodeSystemComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetCodeSystemComponentInner(ValueSet.ValueSetCodeSystemComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasCaseSensitiveElement()) {
      composeBooleanCore("caseSensitive", element.getCaseSensitiveElement(), false);
      composeBooleanExtras("caseSensitive", element.getCaseSensitiveElement(), false);
    }
    if (element.hasConcept()) {
      openArray("concept");
      for (ValueSet.ConceptDefinitionComponent e : element.getConcept())
        composeValueSetConceptDefinitionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetConceptDefinitionComponent(String name, ValueSet.ConceptDefinitionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetConceptDefinitionComponentInner(element);
      close();
    }
  }

  protected void composeValueSetConceptDefinitionComponentInner(ValueSet.ConceptDefinitionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasAbstractElement()) {
      composeBooleanCore("abstract", element.getAbstractElement(), false);
      composeBooleanExtras("abstract", element.getAbstractElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasDefinitionElement()) {
      composeStringCore("definition", element.getDefinitionElement(), false);
      composeStringExtras("definition", element.getDefinitionElement(), false);
    }
    if (element.hasDesignation()) {
      openArray("designation");
      for (ValueSet.ConceptDefinitionDesignationComponent e : element.getDesignation())
        composeValueSetConceptDefinitionDesignationComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasConcept()) {
      openArray("concept");
      for (ValueSet.ConceptDefinitionComponent e : element.getConcept())
        composeValueSetConceptDefinitionComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetConceptDefinitionDesignationComponent(String name,
      ValueSet.ConceptDefinitionDesignationComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeValueSetConceptDefinitionDesignationComponentInner(element);
      close();
    }
  }

  protected void composeValueSetConceptDefinitionDesignationComponentInner(
      ValueSet.ConceptDefinitionDesignationComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasLanguageElement()) {
      composeCodeCore("language", element.getLanguageElement(), false);
      composeCodeExtras("language", element.getLanguageElement(), false);
    }
    if (element.hasUse()) {
      composeCoding("use", element.getUse());
    }
    if (element.hasValueElement()) {
      composeStringCore("value", element.getValueElement(), false);
      composeStringExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeValueSetValueSetComposeComponent(String name, ValueSet.ValueSetComposeComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetComposeComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetComposeComponentInner(ValueSet.ValueSetComposeComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasImport()) {
      openArray("import");
      for (UriType e : element.getImport())
        composeUriCore(null, e, true);
      closeArray();
      if (anyHasExtras(element.getImport())) {
        openArray("_import");
        for (UriType e : element.getImport())
          composeUriExtras(null, e, true);
        closeArray();
      }
    }
    ;
    if (element.hasInclude()) {
      openArray("include");
      for (ValueSet.ConceptSetComponent e : element.getInclude())
        composeValueSetConceptSetComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasExclude()) {
      openArray("exclude");
      for (ValueSet.ConceptSetComponent e : element.getExclude())
        composeValueSetConceptSetComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetConceptSetComponent(String name, ValueSet.ConceptSetComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetConceptSetComponentInner(element);
      close();
    }
  }

  protected void composeValueSetConceptSetComponentInner(ValueSet.ConceptSetComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasConcept()) {
      openArray("concept");
      for (ValueSet.ConceptReferenceComponent e : element.getConcept())
        composeValueSetConceptReferenceComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasFilter()) {
      openArray("filter");
      for (ValueSet.ConceptSetFilterComponent e : element.getFilter())
        composeValueSetConceptSetFilterComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetConceptReferenceComponent(String name, ValueSet.ConceptReferenceComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetConceptReferenceComponentInner(element);
      close();
    }
  }

  protected void composeValueSetConceptReferenceComponentInner(ValueSet.ConceptReferenceComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasDesignation()) {
      openArray("designation");
      for (ValueSet.ConceptDefinitionDesignationComponent e : element.getDesignation())
        composeValueSetConceptDefinitionDesignationComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetConceptSetFilterComponent(String name, ValueSet.ConceptSetFilterComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetConceptSetFilterComponentInner(element);
      close();
    }
  }

  protected void composeValueSetConceptSetFilterComponentInner(ValueSet.ConceptSetFilterComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasPropertyElement()) {
      composeCodeCore("property", element.getPropertyElement(), false);
      composeCodeExtras("property", element.getPropertyElement(), false);
    }
    if (element.hasOpElement()) {
      composeEnumerationCore("op", element.getOpElement(), new ValueSet.FilterOperatorEnumFactory(), false);
      composeEnumerationExtras("op", element.getOpElement(), new ValueSet.FilterOperatorEnumFactory(), false);
    }
    if (element.hasValueElement()) {
      composeCodeCore("value", element.getValueElement(), false);
      composeCodeExtras("value", element.getValueElement(), false);
    }
  }

  protected void composeValueSetValueSetExpansionComponent(String name, ValueSet.ValueSetExpansionComponent element)
      throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetExpansionComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetExpansionComponentInner(ValueSet.ValueSetExpansionComponent element)
      throws IOException {
    composeBackbone(element);
    if (element.hasIdentifierElement()) {
      composeUriCore("identifier", element.getIdentifierElement(), false);
      composeUriExtras("identifier", element.getIdentifierElement(), false);
    }
    if (element.hasTimestampElement()) {
      composeDateTimeCore("timestamp", element.getTimestampElement(), false);
      composeDateTimeExtras("timestamp", element.getTimestampElement(), false);
    }
    if (element.hasTotalElement()) {
      composeIntegerCore("total", element.getTotalElement(), false);
      composeIntegerExtras("total", element.getTotalElement(), false);
    }
    if (element.hasOffsetElement()) {
      composeIntegerCore("offset", element.getOffsetElement(), false);
      composeIntegerExtras("offset", element.getOffsetElement(), false);
    }
    if (element.hasParameter()) {
      openArray("parameter");
      for (ValueSet.ValueSetExpansionParameterComponent e : element.getParameter())
        composeValueSetValueSetExpansionParameterComponent(null, e);
      closeArray();
    }
    ;
    if (element.hasContains()) {
      openArray("contains");
      for (ValueSet.ValueSetExpansionContainsComponent e : element.getContains())
        composeValueSetValueSetExpansionContainsComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeValueSetValueSetExpansionParameterComponent(String name,
      ValueSet.ValueSetExpansionParameterComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetExpansionParameterComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetExpansionParameterComponentInner(
      ValueSet.ValueSetExpansionParameterComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasNameElement()) {
      composeStringCore("name", element.getNameElement(), false);
      composeStringExtras("name", element.getNameElement(), false);
    }
    if (element.hasValue()) {
      composeType("value", element.getValue());
    }
  }

  protected void composeValueSetValueSetExpansionContainsComponent(String name,
      ValueSet.ValueSetExpansionContainsComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeValueSetValueSetExpansionContainsComponentInner(element);
      close();
    }
  }

  protected void composeValueSetValueSetExpansionContainsComponentInner(
      ValueSet.ValueSetExpansionContainsComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasSystemElement()) {
      composeUriCore("system", element.getSystemElement(), false);
      composeUriExtras("system", element.getSystemElement(), false);
    }
    if (element.hasAbstractElement()) {
      composeBooleanCore("abstract", element.getAbstractElement(), false);
      composeBooleanExtras("abstract", element.getAbstractElement(), false);
    }
    if (element.hasVersionElement()) {
      composeStringCore("version", element.getVersionElement(), false);
      composeStringExtras("version", element.getVersionElement(), false);
    }
    if (element.hasCodeElement()) {
      composeCodeCore("code", element.getCodeElement(), false);
      composeCodeExtras("code", element.getCodeElement(), false);
    }
    if (element.hasDisplayElement()) {
      composeStringCore("display", element.getDisplayElement(), false);
      composeStringExtras("display", element.getDisplayElement(), false);
    }
    if (element.hasContains()) {
      openArray("contains");
      for (ValueSet.ValueSetExpansionContainsComponent e : element.getContains())
        composeValueSetValueSetExpansionContainsComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeVisionPrescription(String name, VisionPrescription element) throws IOException {
    if (element != null) {
      prop("resourceType", name);
      composeVisionPrescriptionInner(element);
    }
  }

  protected void composeVisionPrescriptionInner(VisionPrescription element) throws IOException {
    composeDomainResourceElements(element);
    if (element.hasIdentifier()) {
      openArray("identifier");
      for (Identifier e : element.getIdentifier())
        composeIdentifier(null, e);
      closeArray();
    }
    ;
    if (element.hasDateWrittenElement()) {
      composeDateTimeCore("dateWritten", element.getDateWrittenElement(), false);
      composeDateTimeExtras("dateWritten", element.getDateWrittenElement(), false);
    }
    if (element.hasPatient()) {
      composeReference("patient", element.getPatient());
    }
    if (element.hasPrescriber()) {
      composeReference("prescriber", element.getPrescriber());
    }
    if (element.hasEncounter()) {
      composeReference("encounter", element.getEncounter());
    }
    if (element.hasReason()) {
      composeType("reason", element.getReason());
    }
    if (element.hasDispense()) {
      openArray("dispense");
      for (VisionPrescription.VisionPrescriptionDispenseComponent e : element.getDispense())
        composeVisionPrescriptionVisionPrescriptionDispenseComponent(null, e);
      closeArray();
    }
    ;
  }

  protected void composeVisionPrescriptionVisionPrescriptionDispenseComponent(String name,
      VisionPrescription.VisionPrescriptionDispenseComponent element) throws IOException {
    if (element != null) {
      open(name);
      composeVisionPrescriptionVisionPrescriptionDispenseComponentInner(element);
      close();
    }
  }

  protected void composeVisionPrescriptionVisionPrescriptionDispenseComponentInner(
      VisionPrescription.VisionPrescriptionDispenseComponent element) throws IOException {
    composeBackbone(element);
    if (element.hasProduct()) {
      composeCoding("product", element.getProduct());
    }
    if (element.hasEyeElement()) {
      composeEnumerationCore("eye", element.getEyeElement(), new VisionPrescription.VisionEyesEnumFactory(), false);
      composeEnumerationExtras("eye", element.getEyeElement(), new VisionPrescription.VisionEyesEnumFactory(), false);
    }
    if (element.hasSphereElement()) {
      composeDecimalCore("sphere", element.getSphereElement(), false);
      composeDecimalExtras("sphere", element.getSphereElement(), false);
    }
    if (element.hasCylinderElement()) {
      composeDecimalCore("cylinder", element.getCylinderElement(), false);
      composeDecimalExtras("cylinder", element.getCylinderElement(), false);
    }
    if (element.hasAxisElement()) {
      composeIntegerCore("axis", element.getAxisElement(), false);
      composeIntegerExtras("axis", element.getAxisElement(), false);
    }
    if (element.hasPrismElement()) {
      composeDecimalCore("prism", element.getPrismElement(), false);
      composeDecimalExtras("prism", element.getPrismElement(), false);
    }
    if (element.hasBaseElement()) {
      composeEnumerationCore("base", element.getBaseElement(), new VisionPrescription.VisionBaseEnumFactory(), false);
      composeEnumerationExtras("base", element.getBaseElement(), new VisionPrescription.VisionBaseEnumFactory(), false);
    }
    if (element.hasAddElement()) {
      composeDecimalCore("add", element.getAddElement(), false);
      composeDecimalExtras("add", element.getAddElement(), false);
    }
    if (element.hasPowerElement()) {
      composeDecimalCore("power", element.getPowerElement(), false);
      composeDecimalExtras("power", element.getPowerElement(), false);
    }
    if (element.hasBackCurveElement()) {
      composeDecimalCore("backCurve", element.getBackCurveElement(), false);
      composeDecimalExtras("backCurve", element.getBackCurveElement(), false);
    }
    if (element.hasDiameterElement()) {
      composeDecimalCore("diameter", element.getDiameterElement(), false);
      composeDecimalExtras("diameter", element.getDiameterElement(), false);
    }
    if (element.hasDuration()) {
      composeSimpleQuantity("duration", element.getDuration());
    }
    if (element.hasColorElement()) {
      composeStringCore("color", element.getColorElement(), false);
      composeStringExtras("color", element.getColorElement(), false);
    }
    if (element.hasBrandElement()) {
      composeStringCore("brand", element.getBrandElement(), false);
      composeStringExtras("brand", element.getBrandElement(), false);
    }
    if (element.hasNotesElement()) {
      composeStringCore("notes", element.getNotesElement(), false);
      composeStringExtras("notes", element.getNotesElement(), false);
    }
  }

  @Override
  protected void composeResource(Resource resource) throws IOException {
    if (resource instanceof Parameters)
      composeParameters("Parameters", (Parameters) resource);
    else if (resource instanceof Account)
      composeAccount("Account", (Account) resource);
    else if (resource instanceof AllergyIntolerance)
      composeAllergyIntolerance("AllergyIntolerance", (AllergyIntolerance) resource);
    else if (resource instanceof Appointment)
      composeAppointment("Appointment", (Appointment) resource);
    else if (resource instanceof AppointmentResponse)
      composeAppointmentResponse("AppointmentResponse", (AppointmentResponse) resource);
    else if (resource instanceof AuditEvent)
      composeAuditEvent("AuditEvent", (AuditEvent) resource);
    else if (resource instanceof Basic)
      composeBasic("Basic", (Basic) resource);
    else if (resource instanceof Binary)
      composeBinary("Binary", (Binary) resource);
    else if (resource instanceof BodySite)
      composeBodySite("BodySite", (BodySite) resource);
    else if (resource instanceof Bundle)
      composeBundle("Bundle", (Bundle) resource);
    else if (resource instanceof CarePlan)
      composeCarePlan("CarePlan", (CarePlan) resource);
    else if (resource instanceof Claim)
      composeClaim("Claim", (Claim) resource);
    else if (resource instanceof ClaimResponse)
      composeClaimResponse("ClaimResponse", (ClaimResponse) resource);
    else if (resource instanceof ClinicalImpression)
      composeClinicalImpression("ClinicalImpression", (ClinicalImpression) resource);
    else if (resource instanceof Communication)
      composeCommunication("Communication", (Communication) resource);
    else if (resource instanceof CommunicationRequest)
      composeCommunicationRequest("CommunicationRequest", (CommunicationRequest) resource);
    else if (resource instanceof Composition)
      composeComposition("Composition", (Composition) resource);
    else if (resource instanceof ConceptMap)
      composeConceptMap("ConceptMap", (ConceptMap) resource);
    else if (resource instanceof Condition)
      composeCondition("Condition", (Condition) resource);
    else if (resource instanceof Conformance)
      composeConformance("Conformance", (Conformance) resource);
    else if (resource instanceof Contract)
      composeContract("Contract", (Contract) resource);
    else if (resource instanceof Coverage)
      composeCoverage("Coverage", (Coverage) resource);
    else if (resource instanceof DataElement)
      composeDataElement("DataElement", (DataElement) resource);
    else if (resource instanceof DetectedIssue)
      composeDetectedIssue("DetectedIssue", (DetectedIssue) resource);
    else if (resource instanceof Device)
      composeDevice("Device", (Device) resource);
    else if (resource instanceof DeviceComponent)
      composeDeviceComponent("DeviceComponent", (DeviceComponent) resource);
    else if (resource instanceof DeviceMetric)
      composeDeviceMetric("DeviceMetric", (DeviceMetric) resource);
    else if (resource instanceof DeviceUseRequest)
      composeDeviceUseRequest("DeviceUseRequest", (DeviceUseRequest) resource);
    else if (resource instanceof DeviceUseStatement)
      composeDeviceUseStatement("DeviceUseStatement", (DeviceUseStatement) resource);
    else if (resource instanceof DiagnosticOrder)
      composeDiagnosticOrder("DiagnosticOrder", (DiagnosticOrder) resource);
    else if (resource instanceof DiagnosticReport)
      composeDiagnosticReport("DiagnosticReport", (DiagnosticReport) resource);
    else if (resource instanceof DocumentManifest)
      composeDocumentManifest("DocumentManifest", (DocumentManifest) resource);
    else if (resource instanceof DocumentReference)
      composeDocumentReference("DocumentReference", (DocumentReference) resource);
    else if (resource instanceof EligibilityRequest)
      composeEligibilityRequest("EligibilityRequest", (EligibilityRequest) resource);
    else if (resource instanceof EligibilityResponse)
      composeEligibilityResponse("EligibilityResponse", (EligibilityResponse) resource);
    else if (resource instanceof Encounter)
      composeEncounter("Encounter", (Encounter) resource);
    else if (resource instanceof EnrollmentRequest)
      composeEnrollmentRequest("EnrollmentRequest", (EnrollmentRequest) resource);
    else if (resource instanceof EnrollmentResponse)
      composeEnrollmentResponse("EnrollmentResponse", (EnrollmentResponse) resource);
    else if (resource instanceof EpisodeOfCare)
      composeEpisodeOfCare("EpisodeOfCare", (EpisodeOfCare) resource);
    else if (resource instanceof ExplanationOfBenefit)
      composeExplanationOfBenefit("ExplanationOfBenefit", (ExplanationOfBenefit) resource);
    else if (resource instanceof FamilyMemberHistory)
      composeFamilyMemberHistory("FamilyMemberHistory", (FamilyMemberHistory) resource);
    else if (resource instanceof Flag)
      composeFlag("Flag", (Flag) resource);
    else if (resource instanceof Goal)
      composeGoal("Goal", (Goal) resource);
    else if (resource instanceof Group)
      composeGroup("Group", (Group) resource);
    else if (resource instanceof HealthcareService)
      composeHealthcareService("HealthcareService", (HealthcareService) resource);
    else if (resource instanceof ImagingObjectSelection)
      composeImagingObjectSelection("ImagingObjectSelection", (ImagingObjectSelection) resource);
    else if (resource instanceof ImagingStudy)
      composeImagingStudy("ImagingStudy", (ImagingStudy) resource);
    else if (resource instanceof Immunization)
      composeImmunization("Immunization", (Immunization) resource);
    else if (resource instanceof ImmunizationRecommendation)
      composeImmunizationRecommendation("ImmunizationRecommendation", (ImmunizationRecommendation) resource);
    else if (resource instanceof ImplementationGuide)
      composeImplementationGuide("ImplementationGuide", (ImplementationGuide) resource);
    else if (resource instanceof List_)
      composeList_("List", (List_) resource);
    else if (resource instanceof Location)
      composeLocation("Location", (Location) resource);
    else if (resource instanceof Media)
      composeMedia("Media", (Media) resource);
    else if (resource instanceof Medication)
      composeMedication("Medication", (Medication) resource);
    else if (resource instanceof MedicationAdministration)
      composeMedicationAdministration("MedicationAdministration", (MedicationAdministration) resource);
    else if (resource instanceof MedicationDispense)
      composeMedicationDispense("MedicationDispense", (MedicationDispense) resource);
    else if (resource instanceof MedicationOrder)
      composeMedicationOrder("MedicationOrder", (MedicationOrder) resource);
    else if (resource instanceof MedicationStatement)
      composeMedicationStatement("MedicationStatement", (MedicationStatement) resource);
    else if (resource instanceof MessageHeader)
      composeMessageHeader("MessageHeader", (MessageHeader) resource);
    else if (resource instanceof NamingSystem)
      composeNamingSystem("NamingSystem", (NamingSystem) resource);
    else if (resource instanceof NutritionOrder)
      composeNutritionOrder("NutritionOrder", (NutritionOrder) resource);
    else if (resource instanceof Observation)
      composeObservation("Observation", (Observation) resource);
    else if (resource instanceof OperationDefinition)
      composeOperationDefinition("OperationDefinition", (OperationDefinition) resource);
    else if (resource instanceof OperationOutcome)
      composeOperationOutcome("OperationOutcome", (OperationOutcome) resource);
    else if (resource instanceof Order)
      composeOrder("Order", (Order) resource);
    else if (resource instanceof OrderResponse)
      composeOrderResponse("OrderResponse", (OrderResponse) resource);
    else if (resource instanceof Organization)
      composeOrganization("Organization", (Organization) resource);
    else if (resource instanceof Patient)
      composePatient("Patient", (Patient) resource);
    else if (resource instanceof PaymentNotice)
      composePaymentNotice("PaymentNotice", (PaymentNotice) resource);
    else if (resource instanceof PaymentReconciliation)
      composePaymentReconciliation("PaymentReconciliation", (PaymentReconciliation) resource);
    else if (resource instanceof Person)
      composePerson("Person", (Person) resource);
    else if (resource instanceof Practitioner)
      composePractitioner("Practitioner", (Practitioner) resource);
    else if (resource instanceof Procedure)
      composeProcedure("Procedure", (Procedure) resource);
    else if (resource instanceof ProcedureRequest)
      composeProcedureRequest("ProcedureRequest", (ProcedureRequest) resource);
    else if (resource instanceof ProcessRequest)
      composeProcessRequest("ProcessRequest", (ProcessRequest) resource);
    else if (resource instanceof ProcessResponse)
      composeProcessResponse("ProcessResponse", (ProcessResponse) resource);
    else if (resource instanceof Provenance)
      composeProvenance("Provenance", (Provenance) resource);
    else if (resource instanceof Questionnaire)
      composeQuestionnaire("Questionnaire", (Questionnaire) resource);
    else if (resource instanceof QuestionnaireResponse)
      composeQuestionnaireResponse("QuestionnaireResponse", (QuestionnaireResponse) resource);
    else if (resource instanceof ReferralRequest)
      composeReferralRequest("ReferralRequest", (ReferralRequest) resource);
    else if (resource instanceof RelatedPerson)
      composeRelatedPerson("RelatedPerson", (RelatedPerson) resource);
    else if (resource instanceof RiskAssessment)
      composeRiskAssessment("RiskAssessment", (RiskAssessment) resource);
    else if (resource instanceof Schedule)
      composeSchedule("Schedule", (Schedule) resource);
    else if (resource instanceof SearchParameter)
      composeSearchParameter("SearchParameter", (SearchParameter) resource);
    else if (resource instanceof Slot)
      composeSlot("Slot", (Slot) resource);
    else if (resource instanceof Specimen)
      composeSpecimen("Specimen", (Specimen) resource);
    else if (resource instanceof StructureDefinition)
      composeStructureDefinition("StructureDefinition", (StructureDefinition) resource);
    else if (resource instanceof Subscription)
      composeSubscription("Subscription", (Subscription) resource);
    else if (resource instanceof Substance)
      composeSubstance("Substance", (Substance) resource);
    else if (resource instanceof SupplyDelivery)
      composeSupplyDelivery("SupplyDelivery", (SupplyDelivery) resource);
    else if (resource instanceof SupplyRequest)
      composeSupplyRequest("SupplyRequest", (SupplyRequest) resource);
    else if (resource instanceof TestScript)
      composeTestScript("TestScript", (TestScript) resource);
    else if (resource instanceof ValueSet)
      composeValueSet("ValueSet", (ValueSet) resource);
    else if (resource instanceof VisionPrescription)
      composeVisionPrescription("VisionPrescription", (VisionPrescription) resource);
    else if (resource instanceof Binary)
      composeBinary("Binary", (Binary) resource);
    else
      throw new Error("Unhandled resource type " + resource.getClass().getName());
  }

  protected void composeNamedReference(String name, Resource resource) throws IOException {
    if (resource instanceof Parameters)
      composeParameters(name, (Parameters) resource);
    else if (resource instanceof Account)
      composeAccount(name, (Account) resource);
    else if (resource instanceof AllergyIntolerance)
      composeAllergyIntolerance(name, (AllergyIntolerance) resource);
    else if (resource instanceof Appointment)
      composeAppointment(name, (Appointment) resource);
    else if (resource instanceof AppointmentResponse)
      composeAppointmentResponse(name, (AppointmentResponse) resource);
    else if (resource instanceof AuditEvent)
      composeAuditEvent(name, (AuditEvent) resource);
    else if (resource instanceof Basic)
      composeBasic(name, (Basic) resource);
    else if (resource instanceof Binary)
      composeBinary(name, (Binary) resource);
    else if (resource instanceof BodySite)
      composeBodySite(name, (BodySite) resource);
    else if (resource instanceof Bundle)
      composeBundle(name, (Bundle) resource);
    else if (resource instanceof CarePlan)
      composeCarePlan(name, (CarePlan) resource);
    else if (resource instanceof Claim)
      composeClaim(name, (Claim) resource);
    else if (resource instanceof ClaimResponse)
      composeClaimResponse(name, (ClaimResponse) resource);
    else if (resource instanceof ClinicalImpression)
      composeClinicalImpression(name, (ClinicalImpression) resource);
    else if (resource instanceof Communication)
      composeCommunication(name, (Communication) resource);
    else if (resource instanceof CommunicationRequest)
      composeCommunicationRequest(name, (CommunicationRequest) resource);
    else if (resource instanceof Composition)
      composeComposition(name, (Composition) resource);
    else if (resource instanceof ConceptMap)
      composeConceptMap(name, (ConceptMap) resource);
    else if (resource instanceof Condition)
      composeCondition(name, (Condition) resource);
    else if (resource instanceof Conformance)
      composeConformance(name, (Conformance) resource);
    else if (resource instanceof Contract)
      composeContract(name, (Contract) resource);
    else if (resource instanceof Coverage)
      composeCoverage(name, (Coverage) resource);
    else if (resource instanceof DataElement)
      composeDataElement(name, (DataElement) resource);
    else if (resource instanceof DetectedIssue)
      composeDetectedIssue(name, (DetectedIssue) resource);
    else if (resource instanceof Device)
      composeDevice(name, (Device) resource);
    else if (resource instanceof DeviceComponent)
      composeDeviceComponent(name, (DeviceComponent) resource);
    else if (resource instanceof DeviceMetric)
      composeDeviceMetric(name, (DeviceMetric) resource);
    else if (resource instanceof DeviceUseRequest)
      composeDeviceUseRequest(name, (DeviceUseRequest) resource);
    else if (resource instanceof DeviceUseStatement)
      composeDeviceUseStatement(name, (DeviceUseStatement) resource);
    else if (resource instanceof DiagnosticOrder)
      composeDiagnosticOrder(name, (DiagnosticOrder) resource);
    else if (resource instanceof DiagnosticReport)
      composeDiagnosticReport(name, (DiagnosticReport) resource);
    else if (resource instanceof DocumentManifest)
      composeDocumentManifest(name, (DocumentManifest) resource);
    else if (resource instanceof DocumentReference)
      composeDocumentReference(name, (DocumentReference) resource);
    else if (resource instanceof EligibilityRequest)
      composeEligibilityRequest(name, (EligibilityRequest) resource);
    else if (resource instanceof EligibilityResponse)
      composeEligibilityResponse(name, (EligibilityResponse) resource);
    else if (resource instanceof Encounter)
      composeEncounter(name, (Encounter) resource);
    else if (resource instanceof EnrollmentRequest)
      composeEnrollmentRequest(name, (EnrollmentRequest) resource);
    else if (resource instanceof EnrollmentResponse)
      composeEnrollmentResponse(name, (EnrollmentResponse) resource);
    else if (resource instanceof EpisodeOfCare)
      composeEpisodeOfCare(name, (EpisodeOfCare) resource);
    else if (resource instanceof ExplanationOfBenefit)
      composeExplanationOfBenefit(name, (ExplanationOfBenefit) resource);
    else if (resource instanceof FamilyMemberHistory)
      composeFamilyMemberHistory(name, (FamilyMemberHistory) resource);
    else if (resource instanceof Flag)
      composeFlag(name, (Flag) resource);
    else if (resource instanceof Goal)
      composeGoal(name, (Goal) resource);
    else if (resource instanceof Group)
      composeGroup(name, (Group) resource);
    else if (resource instanceof HealthcareService)
      composeHealthcareService(name, (HealthcareService) resource);
    else if (resource instanceof ImagingObjectSelection)
      composeImagingObjectSelection(name, (ImagingObjectSelection) resource);
    else if (resource instanceof ImagingStudy)
      composeImagingStudy(name, (ImagingStudy) resource);
    else if (resource instanceof Immunization)
      composeImmunization(name, (Immunization) resource);
    else if (resource instanceof ImmunizationRecommendation)
      composeImmunizationRecommendation(name, (ImmunizationRecommendation) resource);
    else if (resource instanceof ImplementationGuide)
      composeImplementationGuide(name, (ImplementationGuide) resource);
    else if (resource instanceof List_)
      composeList_(name, (List_) resource);
    else if (resource instanceof Location)
      composeLocation(name, (Location) resource);
    else if (resource instanceof Media)
      composeMedia(name, (Media) resource);
    else if (resource instanceof Medication)
      composeMedication(name, (Medication) resource);
    else if (resource instanceof MedicationAdministration)
      composeMedicationAdministration(name, (MedicationAdministration) resource);
    else if (resource instanceof MedicationDispense)
      composeMedicationDispense(name, (MedicationDispense) resource);
    else if (resource instanceof MedicationOrder)
      composeMedicationOrder(name, (MedicationOrder) resource);
    else if (resource instanceof MedicationStatement)
      composeMedicationStatement(name, (MedicationStatement) resource);
    else if (resource instanceof MessageHeader)
      composeMessageHeader(name, (MessageHeader) resource);
    else if (resource instanceof NamingSystem)
      composeNamingSystem(name, (NamingSystem) resource);
    else if (resource instanceof NutritionOrder)
      composeNutritionOrder(name, (NutritionOrder) resource);
    else if (resource instanceof Observation)
      composeObservation(name, (Observation) resource);
    else if (resource instanceof OperationDefinition)
      composeOperationDefinition(name, (OperationDefinition) resource);
    else if (resource instanceof OperationOutcome)
      composeOperationOutcome(name, (OperationOutcome) resource);
    else if (resource instanceof Order)
      composeOrder(name, (Order) resource);
    else if (resource instanceof OrderResponse)
      composeOrderResponse(name, (OrderResponse) resource);
    else if (resource instanceof Organization)
      composeOrganization(name, (Organization) resource);
    else if (resource instanceof Patient)
      composePatient(name, (Patient) resource);
    else if (resource instanceof PaymentNotice)
      composePaymentNotice(name, (PaymentNotice) resource);
    else if (resource instanceof PaymentReconciliation)
      composePaymentReconciliation(name, (PaymentReconciliation) resource);
    else if (resource instanceof Person)
      composePerson(name, (Person) resource);
    else if (resource instanceof Practitioner)
      composePractitioner(name, (Practitioner) resource);
    else if (resource instanceof Procedure)
      composeProcedure(name, (Procedure) resource);
    else if (resource instanceof ProcedureRequest)
      composeProcedureRequest(name, (ProcedureRequest) resource);
    else if (resource instanceof ProcessRequest)
      composeProcessRequest(name, (ProcessRequest) resource);
    else if (resource instanceof ProcessResponse)
      composeProcessResponse(name, (ProcessResponse) resource);
    else if (resource instanceof Provenance)
      composeProvenance(name, (Provenance) resource);
    else if (resource instanceof Questionnaire)
      composeQuestionnaire(name, (Questionnaire) resource);
    else if (resource instanceof QuestionnaireResponse)
      composeQuestionnaireResponse(name, (QuestionnaireResponse) resource);
    else if (resource instanceof ReferralRequest)
      composeReferralRequest(name, (ReferralRequest) resource);
    else if (resource instanceof RelatedPerson)
      composeRelatedPerson(name, (RelatedPerson) resource);
    else if (resource instanceof RiskAssessment)
      composeRiskAssessment(name, (RiskAssessment) resource);
    else if (resource instanceof Schedule)
      composeSchedule(name, (Schedule) resource);
    else if (resource instanceof SearchParameter)
      composeSearchParameter(name, (SearchParameter) resource);
    else if (resource instanceof Slot)
      composeSlot(name, (Slot) resource);
    else if (resource instanceof Specimen)
      composeSpecimen(name, (Specimen) resource);
    else if (resource instanceof StructureDefinition)
      composeStructureDefinition(name, (StructureDefinition) resource);
    else if (resource instanceof Subscription)
      composeSubscription(name, (Subscription) resource);
    else if (resource instanceof Substance)
      composeSubstance(name, (Substance) resource);
    else if (resource instanceof SupplyDelivery)
      composeSupplyDelivery(name, (SupplyDelivery) resource);
    else if (resource instanceof SupplyRequest)
      composeSupplyRequest(name, (SupplyRequest) resource);
    else if (resource instanceof TestScript)
      composeTestScript(name, (TestScript) resource);
    else if (resource instanceof ValueSet)
      composeValueSet(name, (ValueSet) resource);
    else if (resource instanceof VisionPrescription)
      composeVisionPrescription(name, (VisionPrescription) resource);
    else if (resource instanceof Binary)
      composeBinary(name, (Binary) resource);
    else
      throw new Error("Unhandled resource type " + resource.getClass().getName());
  }

  protected void composeType(String prefix, Type type) throws IOException {
    if (type == null)
      ;
    else if (type instanceof Money)
      composeMoney(prefix + "Money", (Money) type);
    else if (type instanceof SimpleQuantity)
      composeSimpleQuantity(prefix + "SimpleQuantity", (SimpleQuantity) type);
    else if (type instanceof Duration)
      composeDuration(prefix + "Duration", (Duration) type);
    else if (type instanceof Count)
      composeCount(prefix + "Count", (Count) type);
    else if (type instanceof Distance)
      composeDistance(prefix + "Distance", (Distance) type);
    else if (type instanceof Age)
      composeAge(prefix + "Age", (Age) type);
    else if (type instanceof Identifier)
      composeIdentifier(prefix + "Identifier", (Identifier) type);
    else if (type instanceof Coding)
      composeCoding(prefix + "Coding", (Coding) type);
    else if (type instanceof Reference)
      composeReference(prefix + "Reference", (Reference) type);
    else if (type instanceof Signature)
      composeSignature(prefix + "Signature", (Signature) type);
    else if (type instanceof SampledData)
      composeSampledData(prefix + "SampledData", (SampledData) type);
    else if (type instanceof Quantity)
      composeQuantity(prefix + "Quantity", (Quantity) type);
    else if (type instanceof Period)
      composePeriod(prefix + "Period", (Period) type);
    else if (type instanceof Attachment)
      composeAttachment(prefix + "Attachment", (Attachment) type);
    else if (type instanceof Ratio)
      composeRatio(prefix + "Ratio", (Ratio) type);
    else if (type instanceof Range)
      composeRange(prefix + "Range", (Range) type);
    else if (type instanceof Annotation)
      composeAnnotation(prefix + "Annotation", (Annotation) type);
    else if (type instanceof CodeableConcept)
      composeCodeableConcept(prefix + "CodeableConcept", (CodeableConcept) type);
    else if (type instanceof HumanName)
      composeHumanName(prefix + "HumanName", (HumanName) type);
    else if (type instanceof ContactPoint)
      composeContactPoint(prefix + "ContactPoint", (ContactPoint) type);
    else if (type instanceof Meta)
      composeMeta(prefix + "Meta", (Meta) type);
    else if (type instanceof Address)
      composeAddress(prefix + "Address", (Address) type);
    else if (type instanceof Timing)
      composeTiming(prefix + "Timing", (Timing) type);
    else if (type instanceof ElementDefinition)
      composeElementDefinition(prefix + "ElementDefinition", (ElementDefinition) type);
    else if (type instanceof DateType) {
      composeDateCore(prefix + "Date", (DateType) type, false);
      composeDateExtras(prefix + "Date", (DateType) type, false);
    } else if (type instanceof DateTimeType) {
      composeDateTimeCore(prefix + "DateTime", (DateTimeType) type, false);
      composeDateTimeExtras(prefix + "DateTime", (DateTimeType) type, false);
    } else if (type instanceof CodeType) {
      composeCodeCore(prefix + "Code", (CodeType) type, false);
      composeCodeExtras(prefix + "Code", (CodeType) type, false);
    } else if (type instanceof StringType) {
      composeStringCore(prefix + "String", (StringType) type, false);
      composeStringExtras(prefix + "String", (StringType) type, false);
    } else if (type instanceof IntegerType) {
      composeIntegerCore(prefix + "Integer", (IntegerType) type, false);
      composeIntegerExtras(prefix + "Integer", (IntegerType) type, false);
    } else if (type instanceof OidType) {
      composeOidCore(prefix + "Oid", (OidType) type, false);
      composeOidExtras(prefix + "Oid", (OidType) type, false);
    } else if (type instanceof UriType) {
      composeUriCore(prefix + "Uri", (UriType) type, false);
      composeUriExtras(prefix + "Uri", (UriType) type, false);
    } else if (type instanceof UuidType) {
      composeUuidCore(prefix + "Uuid", (UuidType) type, false);
      composeUuidExtras(prefix + "Uuid", (UuidType) type, false);
    } else if (type instanceof InstantType) {
      composeInstantCore(prefix + "Instant", (InstantType) type, false);
      composeInstantExtras(prefix + "Instant", (InstantType) type, false);
    } else if (type instanceof BooleanType) {
      composeBooleanCore(prefix + "Boolean", (BooleanType) type, false);
      composeBooleanExtras(prefix + "Boolean", (BooleanType) type, false);
    } else if (type instanceof Base64BinaryType) {
      composeBase64BinaryCore(prefix + "Base64Binary", (Base64BinaryType) type, false);
      composeBase64BinaryExtras(prefix + "Base64Binary", (Base64BinaryType) type, false);
    } else if (type instanceof UnsignedIntType) {
      composeUnsignedIntCore(prefix + "UnsignedInt", (UnsignedIntType) type, false);
      composeUnsignedIntExtras(prefix + "UnsignedInt", (UnsignedIntType) type, false);
    } else if (type instanceof MarkdownType) {
      composeMarkdownCore(prefix + "Markdown", (MarkdownType) type, false);
      composeMarkdownExtras(prefix + "Markdown", (MarkdownType) type, false);
    } else if (type instanceof TimeType) {
      composeTimeCore(prefix + "Time", (TimeType) type, false);
      composeTimeExtras(prefix + "Time", (TimeType) type, false);
    } else if (type instanceof IdType) {
      composeIdCore(prefix + "Id", (IdType) type, false);
      composeIdExtras(prefix + "Id", (IdType) type, false);
    } else if (type instanceof PositiveIntType) {
      composePositiveIntCore(prefix + "PositiveInt", (PositiveIntType) type, false);
      composePositiveIntExtras(prefix + "PositiveInt", (PositiveIntType) type, false);
    } else if (type instanceof DecimalType) {
      composeDecimalCore(prefix + "Decimal", (DecimalType) type, false);
      composeDecimalExtras(prefix + "Decimal", (DecimalType) type, false);
    } else
      throw new Error("Unhandled type");
  }

  protected void composeTypeInner(Type type) throws IOException {
    if (type == null)
      ;
    else if (type instanceof Identifier)
      composeIdentifierInner((Identifier) type);
    else if (type instanceof Coding)
      composeCodingInner((Coding) type);
    else if (type instanceof Reference)
      composeReferenceInner((Reference) type);
    else if (type instanceof Signature)
      composeSignatureInner((Signature) type);
    else if (type instanceof SampledData)
      composeSampledDataInner((SampledData) type);
    else if (type instanceof Quantity)
      composeQuantityInner((Quantity) type);
    else if (type instanceof Period)
      composePeriodInner((Period) type);
    else if (type instanceof Attachment)
      composeAttachmentInner((Attachment) type);
    else if (type instanceof Ratio)
      composeRatioInner((Ratio) type);
    else if (type instanceof Range)
      composeRangeInner((Range) type);
    else if (type instanceof Annotation)
      composeAnnotationInner((Annotation) type);
    else if (type instanceof CodeableConcept)
      composeCodeableConceptInner((CodeableConcept) type);
    else if (type instanceof Money)
      composeMoneyInner((Money) type);
    else if (type instanceof SimpleQuantity)
      composeSimpleQuantityInner((SimpleQuantity) type);
    else if (type instanceof Duration)
      composeDurationInner((Duration) type);
    else if (type instanceof Count)
      composeCountInner((Count) type);
    else if (type instanceof Distance)
      composeDistanceInner((Distance) type);
    else if (type instanceof Age)
      composeAgeInner((Age) type);
    else if (type instanceof HumanName)
      composeHumanNameInner((HumanName) type);
    else if (type instanceof ContactPoint)
      composeContactPointInner((ContactPoint) type);
    else if (type instanceof Meta)
      composeMetaInner((Meta) type);
    else if (type instanceof Address)
      composeAddressInner((Address) type);
    else if (type instanceof Timing)
      composeTimingInner((Timing) type);
    else if (type instanceof ElementDefinition)
      composeElementDefinitionInner((ElementDefinition) type);
    else
      throw new Error("Unhandled type");
  }

}