package org.hl7.fhir.r5.formats;

// generated

/*
  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 Sat, Nov 5, 2022 10:47+1100 for FHIR v5.0.0-ballot



import org.hl7.fhir.r5.model.*;
import org.hl7.fhir.utilities.Utilities;
import org.hl7.fhir.utilities.xhtml.XhtmlNode;
import org.hl7.fhir.exceptions.FHIRFormatError;
import org.hl7.fhir.exceptions.FHIRException;
import org.hl7.fhir.utilities.json.JsonTrackingParser.PresentedBigDecimal;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import java.io.IOException;

public class JsonParser extends JsonParserBase {

  public JsonParser() {
    super();
  }

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

  public JsonParser(boolean allowUnknownContent, boolean allowComments) {
    super();
    setAllowUnknownContent(allowUnknownContent);
    setAllowComments(allowComments);
  }

  protected void parseBaseProperties(JsonObject json, Base res) throws IOException, FHIRFormatError {
    // nothing
  }

  @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 Integer64Type parseInteger64(java.lang.Long v) throws IOException, FHIRFormatError {
    Integer64Type res = new Integer64Type(v);
    return res;
  }

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

  protected CanonicalType parseCanonical(String v) throws IOException, FHIRFormatError {
    CanonicalType res = new CanonicalType(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 UrlType parseUrl(String v) throws IOException, FHIRFormatError {
    UrlType res = new UrlType(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);
    if (v instanceof PresentedBigDecimal)
      res.setRepresentation(((PresentedBigDecimal) v).getPresentation());
    return res;
  }



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

  protected void parseBackboneTypeProperties(JsonObject json, BackboneType res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("modifierExtension")) {
      JsonArray array = getJArray(json, "modifierExtension");
      for (int i = 0; i < array.size(); i++) {
        res.getModifierExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected void parseDataTypeProperties(JsonObject json, DataType res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
  }

  protected void parseElementProperties(JsonObject json, Element res) throws IOException, FHIRFormatError {
    if (json.has("id"))
      res.setIdElement(parseString(json.get("id").getAsString()));
    if (json.has("_id"))
      parseElementProperties(getJObject(json, "_id"), res.getIdElement());
    if (json.has("extension")) {
      JsonArray array = getJArray(json, "extension");
      for (int i = 0; i < array.size(); i++) {
        res.getExtension().add(parseExtension(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Address parseAddress(JsonObject json) throws IOException, FHIRFormatError {
    Address res = new Address();
    parseAddressProperties(json, res);
    return res;
  }

  protected void parseAddressProperties(JsonObject json, Address res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Address.AddressUse.NULL, new Address.AddressUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
    if (json.has("line")) {
      JsonArray array = getJArray(json, "line");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getLine().add(new StringType());
        } else {;
          res.getLine().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_line")) {
      JsonArray array = getJArray(json, "_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(getJObject(json, "_city"), res.getCityElement());
    if (json.has("district"))
      res.setDistrictElement(parseString(json.get("district").getAsString()));
    if (json.has("_district"))
      parseElementProperties(getJObject(json, "_district"), res.getDistrictElement());
    if (json.has("state"))
      res.setStateElement(parseString(json.get("state").getAsString()));
    if (json.has("_state"))
      parseElementProperties(getJObject(json, "_state"), res.getStateElement());
    if (json.has("postalCode"))
      res.setPostalCodeElement(parseString(json.get("postalCode").getAsString()));
    if (json.has("_postalCode"))
      parseElementProperties(getJObject(json, "_postalCode"), res.getPostalCodeElement());
    if (json.has("country"))
      res.setCountryElement(parseString(json.get("country").getAsString()));
    if (json.has("_country"))
      parseElementProperties(getJObject(json, "_country"), res.getCountryElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Age parseAge(JsonObject json) throws IOException, FHIRFormatError {
    Age res = new Age();
    parseAgeProperties(json, res);
    return res;
  }

  protected void parseAgeProperties(JsonObject json, Age res) throws IOException, FHIRFormatError {
    parseQuantityProperties(json, res);
  }

  protected Annotation parseAnnotation(JsonObject json) throws IOException, FHIRFormatError {
    Annotation res = new Annotation();
    parseAnnotationProperties(json, res);
    return res;
  }

  protected void parseAnnotationProperties(JsonObject json, Annotation res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    DataType 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(getJObject(json, "_time"), res.getTimeElement());
    if (json.has("text"))
      res.setTextElement(parseMarkdown(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
  }

  protected Attachment parseAttachment(JsonObject json) throws IOException, FHIRFormatError {
    Attachment res = new Attachment();
    parseAttachmentProperties(json, res);
    return res;
  }

  protected void parseAttachmentProperties(JsonObject json, Attachment res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("contentType"))
      res.setContentTypeElement(parseCode(json.get("contentType").getAsString()));
    if (json.has("_contentType"))
      parseElementProperties(getJObject(json, "_contentType"), res.getContentTypeElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(getJObject(json, "_language"), res.getLanguageElement());
    if (json.has("data"))
      res.setDataElement(parseBase64Binary(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(getJObject(json, "_data"), res.getDataElement());
    if (json.has("url"))
      res.setUrlElement(parseUrl(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("size"))
      res.setSizeElement(parseInteger64(json.get("size").getAsLong()));
    if (json.has("_size"))
      parseElementProperties(getJObject(json, "_size"), res.getSizeElement());
    if (json.has("hash"))
      res.setHashElement(parseBase64Binary(json.get("hash").getAsString()));
    if (json.has("_hash"))
      parseElementProperties(getJObject(json, "_hash"), res.getHashElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("creation"))
      res.setCreationElement(parseDateTime(json.get("creation").getAsString()));
    if (json.has("_creation"))
      parseElementProperties(getJObject(json, "_creation"), res.getCreationElement());
    if (json.has("height"))
      res.setHeightElement(parsePositiveInt(json.get("height").getAsString()));
    if (json.has("_height"))
      parseElementProperties(getJObject(json, "_height"), res.getHeightElement());
    if (json.has("width"))
      res.setWidthElement(parsePositiveInt(json.get("width").getAsString()));
    if (json.has("_width"))
      parseElementProperties(getJObject(json, "_width"), res.getWidthElement());
    if (json.has("frames"))
      res.setFramesElement(parsePositiveInt(json.get("frames").getAsString()));
    if (json.has("_frames"))
      parseElementProperties(getJObject(json, "_frames"), res.getFramesElement());
    if (json.has("duration"))
      res.setDurationElement(parseDecimal(json.get("duration").getAsBigDecimal()));
    if (json.has("_duration"))
      parseElementProperties(getJObject(json, "_duration"), res.getDurationElement());
    if (json.has("pages"))
      res.setPagesElement(parsePositiveInt(json.get("pages").getAsString()));
    if (json.has("_pages"))
      parseElementProperties(getJObject(json, "_pages"), res.getPagesElement());
  }

  protected Availability parseAvailability(JsonObject json) throws IOException, FHIRFormatError {
    Availability res = new Availability();
    parseAvailabilityProperties(json, res);
    return res;
  }

  protected void parseAvailabilityProperties(JsonObject json, Availability res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("availableTime")) {
      JsonArray array = getJArray(json, "availableTime");
      for (int i = 0; i < array.size(); i++) {
        res.getAvailableTime().add(parseAvailabilityAvailableTimeComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("notAvailableTime")) {
      JsonArray array = getJArray(json, "notAvailableTime");
      for (int i = 0; i < array.size(); i++) {
        res.getNotAvailableTime().add(parseAvailabilityNotAvailableTimeComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Availability.AvailabilityAvailableTimeComponent parseAvailabilityAvailableTimeComponent(JsonObject json) throws IOException, FHIRFormatError {
    Availability.AvailabilityAvailableTimeComponent res = new Availability.AvailabilityAvailableTimeComponent();
    parseAvailabilityAvailableTimeComponentProperties(json, res);
    return res;
  }

  protected void parseAvailabilityAvailableTimeComponentProperties(JsonObject json, Availability.AvailabilityAvailableTimeComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("daysOfWeek")) {
      JsonArray array = getJArray(json, "daysOfWeek");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDaysOfWeek().add(new Enumeration<Enumerations.DaysOfWeek>(new Enumerations.DaysOfWeekEnumFactory(), Enumerations.DaysOfWeek.NULL));
        } else {;
          res.getDaysOfWeek().add(parseEnumeration(array.get(i).getAsString(), Enumerations.DaysOfWeek.NULL, new Enumerations.DaysOfWeekEnumFactory()));
        }
      }
    };
    if (json.has("_daysOfWeek")) {
      JsonArray array = getJArray(json, "_daysOfWeek");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDaysOfWeek().size())
          res.getDaysOfWeek().add(parseEnumeration(null, Enumerations.DaysOfWeek.NULL, new Enumerations.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(getJObject(json, "_allDay"), res.getAllDayElement());
    if (json.has("availableStartTime"))
      res.setAvailableStartTimeElement(parseTime(json.get("availableStartTime").getAsString()));
    if (json.has("_availableStartTime"))
      parseElementProperties(getJObject(json, "_availableStartTime"), res.getAvailableStartTimeElement());
    if (json.has("availableEndTime"))
      res.setAvailableEndTimeElement(parseTime(json.get("availableEndTime").getAsString()));
    if (json.has("_availableEndTime"))
      parseElementProperties(getJObject(json, "_availableEndTime"), res.getAvailableEndTimeElement());
  }

  protected Availability.AvailabilityNotAvailableTimeComponent parseAvailabilityNotAvailableTimeComponent(JsonObject json) throws IOException, FHIRFormatError {
    Availability.AvailabilityNotAvailableTimeComponent res = new Availability.AvailabilityNotAvailableTimeComponent();
    parseAvailabilityNotAvailableTimeComponentProperties(json, res);
    return res;
  }

  protected void parseAvailabilityNotAvailableTimeComponentProperties(JsonObject json, Availability.AvailabilityNotAvailableTimeComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("during"))
      res.setDuring(parsePeriod(getJObject(json, "during")));
  }

  protected CodeableConcept parseCodeableConcept(JsonObject json) throws IOException, FHIRFormatError {
    CodeableConcept res = new CodeableConcept();
    parseCodeableConceptProperties(json, res);
    return res;
  }

  protected void parseCodeableConceptProperties(JsonObject json, CodeableConcept res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("coding")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_text"), res.getTextElement());
  }

  protected CodeableReference parseCodeableReference(JsonObject json) throws IOException, FHIRFormatError {
    CodeableReference res = new CodeableReference();
    parseCodeableReferenceProperties(json, res);
    return res;
  }

  protected void parseCodeableReferenceProperties(JsonObject json, CodeableReference res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("concept"))
      res.setConcept(parseCodeableConcept(getJObject(json, "concept")));
    if (json.has("reference"))
      res.setReference(parseReference(getJObject(json, "reference")));
  }

  protected Coding parseCoding(JsonObject json) throws IOException, FHIRFormatError {
    Coding res = new Coding();
    parseCodingProperties(json, res);
    return res;
  }

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

  protected ContactDetail parseContactDetail(JsonObject json) throws IOException, FHIRFormatError {
    ContactDetail res = new ContactDetail();
    parseContactDetailProperties(json, res);
    return res;
  }

  protected void parseContactDetailProperties(JsonObject json, ContactDetail res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("telecom")) {
      JsonArray array = getJArray(json, "telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ContactPoint parseContactPoint(JsonObject json) throws IOException, FHIRFormatError {
    ContactPoint res = new ContactPoint();
    parseContactPointProperties(json, res);
    return res;
  }

  protected void parseContactPointProperties(JsonObject json, ContactPoint res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("system"))
      res.setSystemElement(parseEnumeration(json.get("system").getAsString(), ContactPoint.ContactPointSystem.NULL, new ContactPoint.ContactPointSystemEnumFactory()));
    if (json.has("_system"))
      parseElementProperties(getJObject(json, "_system"), res.getSystemElement());
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_use"), res.getUseElement());
    if (json.has("rank"))
      res.setRankElement(parsePositiveInt(json.get("rank").getAsString()));
    if (json.has("_rank"))
      parseElementProperties(getJObject(json, "_rank"), res.getRankElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Contributor parseContributor(JsonObject json) throws IOException, FHIRFormatError {
    Contributor res = new Contributor();
    parseContributorProperties(json, res);
    return res;
  }

  protected void parseContributorProperties(JsonObject json, Contributor res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Contributor.ContributorType.NULL, new Contributor.ContributorTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Count parseCount(JsonObject json) throws IOException, FHIRFormatError {
    Count res = new Count();
    parseCountProperties(json, res);
    return res;
  }

  protected void parseCountProperties(JsonObject json, Count res) throws IOException, FHIRFormatError {
    parseQuantityProperties(json, res);
  }

  protected DataRequirement parseDataRequirement(JsonObject json) throws IOException, FHIRFormatError {
    DataRequirement res = new DataRequirement();
    parseDataRequirementProperties(json, res);
    return res;
  }

  protected void parseDataRequirementProperties(JsonObject json, DataRequirement res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.FHIRTypes.NULL, new Enumerations.FHIRTypesEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("profile")) {
      JsonArray array = getJArray(json, "profile");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getProfile().add(new CanonicalType());
        } else {;
          res.getProfile().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_profile")) {
      JsonArray array = getJArray(json, "_profile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProfile().size())
          res.getProfile().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProfile().get(i));
      }
    };
    DataType subject = parseType("subject", json);
    if (subject != null)
      res.setSubject(subject);
    if (json.has("mustSupport")) {
      JsonArray array = getJArray(json, "mustSupport");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getMustSupport().add(new StringType());
        } else {;
          res.getMustSupport().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_mustSupport")) {
      JsonArray array = getJArray(json, "_mustSupport");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getMustSupport().size())
          res.getMustSupport().add(parseString(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getMustSupport().get(i));
      }
    };
    if (json.has("codeFilter")) {
      JsonArray array = getJArray(json, "codeFilter");
      for (int i = 0; i < array.size(); i++) {
        res.getCodeFilter().add(parseDataRequirementCodeFilterComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("dateFilter")) {
      JsonArray array = getJArray(json, "dateFilter");
      for (int i = 0; i < array.size(); i++) {
        res.getDateFilter().add(parseDataRequirementDateFilterComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("valueFilter")) {
      JsonArray array = getJArray(json, "valueFilter");
      for (int i = 0; i < array.size(); i++) {
        res.getValueFilter().add(parseDataRequirementValueFilterComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("limit"))
      res.setLimitElement(parsePositiveInt(json.get("limit").getAsString()));
    if (json.has("_limit"))
      parseElementProperties(getJObject(json, "_limit"), res.getLimitElement());
    if (json.has("sort")) {
      JsonArray array = getJArray(json, "sort");
      for (int i = 0; i < array.size(); i++) {
        res.getSort().add(parseDataRequirementSortComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected DataRequirement.DataRequirementCodeFilterComponent parseDataRequirementCodeFilterComponent(JsonObject json) throws IOException, FHIRFormatError {
    DataRequirement.DataRequirementCodeFilterComponent res = new DataRequirement.DataRequirementCodeFilterComponent();
    parseDataRequirementCodeFilterComponentProperties(json, res);
    return res;
  }

  protected void parseDataRequirementCodeFilterComponentProperties(JsonObject json, DataRequirement.DataRequirementCodeFilterComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("searchParam"))
      res.setSearchParamElement(parseString(json.get("searchParam").getAsString()));
    if (json.has("_searchParam"))
      parseElementProperties(getJObject(json, "_searchParam"), res.getSearchParamElement());
    if (json.has("valueSet"))
      res.setValueSetElement(parseCanonical(json.get("valueSet").getAsString()));
    if (json.has("_valueSet"))
      parseElementProperties(getJObject(json, "_valueSet"), res.getValueSetElement());
    if (json.has("code")) {
      JsonArray array = getJArray(json, "code");
      for (int i = 0; i < array.size(); i++) {
        res.getCode().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected DataRequirement.DataRequirementDateFilterComponent parseDataRequirementDateFilterComponent(JsonObject json) throws IOException, FHIRFormatError {
    DataRequirement.DataRequirementDateFilterComponent res = new DataRequirement.DataRequirementDateFilterComponent();
    parseDataRequirementDateFilterComponentProperties(json, res);
    return res;
  }

  protected void parseDataRequirementDateFilterComponentProperties(JsonObject json, DataRequirement.DataRequirementDateFilterComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("searchParam"))
      res.setSearchParamElement(parseString(json.get("searchParam").getAsString()));
    if (json.has("_searchParam"))
      parseElementProperties(getJObject(json, "_searchParam"), res.getSearchParamElement());
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected DataRequirement.DataRequirementValueFilterComponent parseDataRequirementValueFilterComponent(JsonObject json) throws IOException, FHIRFormatError {
    DataRequirement.DataRequirementValueFilterComponent res = new DataRequirement.DataRequirementValueFilterComponent();
    parseDataRequirementValueFilterComponentProperties(json, res);
    return res;
  }

  protected void parseDataRequirementValueFilterComponentProperties(JsonObject json, DataRequirement.DataRequirementValueFilterComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("searchParam"))
      res.setSearchParamElement(parseString(json.get("searchParam").getAsString()));
    if (json.has("_searchParam"))
      parseElementProperties(getJObject(json, "_searchParam"), res.getSearchParamElement());
    if (json.has("comparator"))
      res.setComparatorElement(parseEnumeration(json.get("comparator").getAsString(), DataRequirement.ValueFilterComparator.NULL, new DataRequirement.ValueFilterComparatorEnumFactory()));
    if (json.has("_comparator"))
      parseElementProperties(getJObject(json, "_comparator"), res.getComparatorElement());
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected DataRequirement.DataRequirementSortComponent parseDataRequirementSortComponent(JsonObject json) throws IOException, FHIRFormatError {
    DataRequirement.DataRequirementSortComponent res = new DataRequirement.DataRequirementSortComponent();
    parseDataRequirementSortComponentProperties(json, res);
    return res;
  }

  protected void parseDataRequirementSortComponentProperties(JsonObject json, DataRequirement.DataRequirementSortComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("direction"))
      res.setDirectionElement(parseEnumeration(json.get("direction").getAsString(), DataRequirement.SortDirection.NULL, new DataRequirement.SortDirectionEnumFactory()));
    if (json.has("_direction"))
      parseElementProperties(getJObject(json, "_direction"), res.getDirectionElement());
  }

  protected Distance parseDistance(JsonObject json) throws IOException, FHIRFormatError {
    Distance res = new Distance();
    parseDistanceProperties(json, res);
    return res;
  }

  protected void parseDistanceProperties(JsonObject json, Distance res) throws IOException, FHIRFormatError {
    parseQuantityProperties(json, res);
  }

  protected Dosage parseDosage(JsonObject json) throws IOException, FHIRFormatError {
    Dosage res = new Dosage();
    parseDosageProperties(json, res);
    return res;
  }

  protected void parseDosageProperties(JsonObject json, Dosage res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parseInteger(json.get("sequence").getAsLong()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
    if (json.has("additionalInstruction")) {
      JsonArray array = getJArray(json, "additionalInstruction");
      for (int i = 0; i < array.size(); i++) {
        res.getAdditionalInstruction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patientInstruction"))
      res.setPatientInstructionElement(parseString(json.get("patientInstruction").getAsString()));
    if (json.has("_patientInstruction"))
      parseElementProperties(getJObject(json, "_patientInstruction"), res.getPatientInstructionElement());
    if (json.has("timing"))
      res.setTiming(parseTiming(getJObject(json, "timing")));
    if (json.has("asNeeded"))
      res.setAsNeededElement(parseBoolean(json.get("asNeeded").getAsBoolean()));
    if (json.has("_asNeeded"))
      parseElementProperties(getJObject(json, "_asNeeded"), res.getAsNeededElement());
    if (json.has("asNeededFor")) {
      JsonArray array = getJArray(json, "asNeededFor");
      for (int i = 0; i < array.size(); i++) {
        res.getAsNeededFor().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("site"))
      res.setSite(parseCodeableConcept(getJObject(json, "site")));
    if (json.has("route"))
      res.setRoute(parseCodeableConcept(getJObject(json, "route")));
    if (json.has("method"))
      res.setMethod(parseCodeableConcept(getJObject(json, "method")));
    if (json.has("doseAndRate")) {
      JsonArray array = getJArray(json, "doseAndRate");
      for (int i = 0; i < array.size(); i++) {
        res.getDoseAndRate().add(parseDosageDoseAndRateComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("maxDosePerPeriod")) {
      JsonArray array = getJArray(json, "maxDosePerPeriod");
      for (int i = 0; i < array.size(); i++) {
        res.getMaxDosePerPeriod().add(parseRatio(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("maxDosePerAdministration"))
      res.setMaxDosePerAdministration(parseQuantity(getJObject(json, "maxDosePerAdministration")));
    if (json.has("maxDosePerLifetime"))
      res.setMaxDosePerLifetime(parseQuantity(getJObject(json, "maxDosePerLifetime")));
  }

  protected Dosage.DosageDoseAndRateComponent parseDosageDoseAndRateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Dosage.DosageDoseAndRateComponent res = new Dosage.DosageDoseAndRateComponent();
    parseDosageDoseAndRateComponentProperties(json, res);
    return res;
  }

  protected void parseDosageDoseAndRateComponentProperties(JsonObject json, Dosage.DosageDoseAndRateComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    DataType dose = parseType("dose", json);
    if (dose != null)
      res.setDose(dose);
    DataType rate = parseType("rate", json);
    if (rate != null)
      res.setRate(rate);
  }

  protected Duration parseDuration(JsonObject json) throws IOException, FHIRFormatError {
    Duration res = new Duration();
    parseDurationProperties(json, res);
    return res;
  }

  protected void parseDurationProperties(JsonObject json, Duration res) throws IOException, FHIRFormatError {
    parseQuantityProperties(json, res);
  }

  protected ElementDefinition parseElementDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition res = new ElementDefinition();
    parseElementDefinitionProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionProperties(JsonObject json, ElementDefinition res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("representation")) {
      JsonArray array = getJArray(json, "representation");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getRepresentation().add(new Enumeration<ElementDefinition.PropertyRepresentation>(new ElementDefinition.PropertyRepresentationEnumFactory(), ElementDefinition.PropertyRepresentation.NULL));
        } else {;
          res.getRepresentation().add(parseEnumeration(array.get(i).getAsString(), ElementDefinition.PropertyRepresentation.NULL, new ElementDefinition.PropertyRepresentationEnumFactory()));
        }
      }
    };
    if (json.has("_representation")) {
      JsonArray array = getJArray(json, "_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("sliceName"))
      res.setSliceNameElement(parseString(json.get("sliceName").getAsString()));
    if (json.has("_sliceName"))
      parseElementProperties(getJObject(json, "_sliceName"), res.getSliceNameElement());
    if (json.has("sliceIsConstraining"))
      res.setSliceIsConstrainingElement(parseBoolean(json.get("sliceIsConstraining").getAsBoolean()));
    if (json.has("_sliceIsConstraining"))
      parseElementProperties(getJObject(json, "_sliceIsConstraining"), res.getSliceIsConstrainingElement());
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(getJObject(json, "_label"), res.getLabelElement());
    if (json.has("code")) {
      JsonArray array = getJArray(json, "code");
      for (int i = 0; i < array.size(); i++) {
        res.getCode().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("slicing"))
      res.setSlicing(parseElementDefinitionSlicingComponent(getJObject(json, "slicing")));
    if (json.has("short"))
      res.setShortElement(parseString(json.get("short").getAsString()));
    if (json.has("_short"))
      parseElementProperties(getJObject(json, "_short"), res.getShortElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseMarkdown(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(getJObject(json, "_definition"), res.getDefinitionElement());
    if (json.has("comment"))
      res.setCommentElement(parseMarkdown(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(getJObject(json, "_comment"), res.getCommentElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseMarkdown(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(getJObject(json, "_requirements"), res.getRequirementsElement());
    if (json.has("alias")) {
      JsonArray array = getJArray(json, "alias");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getAlias().add(new StringType());
        } else {;
          res.getAlias().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_alias")) {
      JsonArray array = getJArray(json, "_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(parseUnsignedInt(json.get("min").getAsString()));
    if (json.has("_min"))
      parseElementProperties(getJObject(json, "_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(getJObject(json, "_max"), res.getMaxElement());
    if (json.has("base"))
      res.setBase(parseElementDefinitionBaseComponent(getJObject(json, "base")));
    if (json.has("contentReference"))
      res.setContentReferenceElement(parseUri(json.get("contentReference").getAsString()));
    if (json.has("_contentReference"))
      parseElementProperties(getJObject(json, "_contentReference"), res.getContentReferenceElement());
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseElementDefinitionTypeRefComponent(array.get(i).getAsJsonObject()));
      }
    };
    DataType 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(getJObject(json, "_meaningWhenMissing"), res.getMeaningWhenMissingElement());
    if (json.has("orderMeaning"))
      res.setOrderMeaningElement(parseString(json.get("orderMeaning").getAsString()));
    if (json.has("_orderMeaning"))
      parseElementProperties(getJObject(json, "_orderMeaning"), res.getOrderMeaningElement());
    DataType fixed = parseType("fixed", json);
    if (fixed != null)
      res.setFixed(fixed);
    DataType pattern = parseType("pattern", json);
    if (pattern != null)
      res.setPattern(pattern);
    if (json.has("example")) {
      JsonArray array = getJArray(json, "example");
      for (int i = 0; i < array.size(); i++) {
        res.getExample().add(parseElementDefinitionExampleComponent(array.get(i).getAsJsonObject()));
      }
    };
    DataType minValue = parseType("minValue", json);
    if (minValue != null)
      res.setMinValue(minValue);
    DataType 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(getJObject(json, "_maxLength"), res.getMaxLengthElement());
    if (json.has("condition")) {
      JsonArray array = getJArray(json, "condition");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getCondition().add(new IdType());
        } else {;
          res.getCondition().add(parseId(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_condition")) {
      JsonArray array = getJArray(json, "_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 = getJArray(json, "constraint");
      for (int i = 0; i < array.size(); i++) {
        res.getConstraint().add(parseElementDefinitionConstraintComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("mustSupport"))
      res.setMustSupportElement(parseBoolean(json.get("mustSupport").getAsBoolean()));
    if (json.has("_mustSupport"))
      parseElementProperties(getJObject(json, "_mustSupport"), res.getMustSupportElement());
    if (json.has("isModifier"))
      res.setIsModifierElement(parseBoolean(json.get("isModifier").getAsBoolean()));
    if (json.has("_isModifier"))
      parseElementProperties(getJObject(json, "_isModifier"), res.getIsModifierElement());
    if (json.has("isModifierReason"))
      res.setIsModifierReasonElement(parseString(json.get("isModifierReason").getAsString()));
    if (json.has("_isModifierReason"))
      parseElementProperties(getJObject(json, "_isModifierReason"), res.getIsModifierReasonElement());
    if (json.has("isSummary"))
      res.setIsSummaryElement(parseBoolean(json.get("isSummary").getAsBoolean()));
    if (json.has("_isSummary"))
      parseElementProperties(getJObject(json, "_isSummary"), res.getIsSummaryElement());
    if (json.has("binding"))
      res.setBinding(parseElementDefinitionBindingComponent(getJObject(json, "binding")));
    if (json.has("mapping")) {
      JsonArray array = getJArray(json, "mapping");
      for (int i = 0; i < array.size(); i++) {
        res.getMapping().add(parseElementDefinitionMappingComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ElementDefinition.ElementDefinitionSlicingComponent parseElementDefinitionSlicingComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionSlicingComponent res = new ElementDefinition.ElementDefinitionSlicingComponent();
    parseElementDefinitionSlicingComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionSlicingComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionSlicingComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("discriminator")) {
      JsonArray array = getJArray(json, "discriminator");
      for (int i = 0; i < array.size(); i++) {
        res.getDiscriminator().add(parseElementDefinitionSlicingDiscriminatorComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("ordered"))
      res.setOrderedElement(parseBoolean(json.get("ordered").getAsBoolean()));
    if (json.has("_ordered"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_rules"), res.getRulesElement());
  }

  protected ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent parseElementDefinitionSlicingDiscriminatorComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent res = new ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent();
    parseElementDefinitionSlicingDiscriminatorComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionSlicingDiscriminatorComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), ElementDefinition.DiscriminatorType.NULL, new ElementDefinition.DiscriminatorTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
  }

  protected ElementDefinition.ElementDefinitionBaseComponent parseElementDefinitionBaseComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionBaseComponent res = new ElementDefinition.ElementDefinitionBaseComponent();
    parseElementDefinitionBaseComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionBaseComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionBaseComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("min"))
      res.setMinElement(parseUnsignedInt(json.get("min").getAsString()));
    if (json.has("_min"))
      parseElementProperties(getJObject(json, "_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(getJObject(json, "_max"), res.getMaxElement());
  }

  protected ElementDefinition.TypeRefComponent parseElementDefinitionTypeRefComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.TypeRefComponent res = new ElementDefinition.TypeRefComponent();
    parseElementDefinitionTypeRefComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionTypeRefComponentProperties(JsonObject json, ElementDefinition.TypeRefComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseUri(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("profile")) {
      JsonArray array = getJArray(json, "profile");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getProfile().add(new CanonicalType());
        } else {;
          res.getProfile().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_profile")) {
      JsonArray array = getJArray(json, "_profile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProfile().size())
          res.getProfile().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProfile().get(i));
      }
    };
    if (json.has("targetProfile")) {
      JsonArray array = getJArray(json, "targetProfile");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getTargetProfile().add(new CanonicalType());
        } else {;
          res.getTargetProfile().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_targetProfile")) {
      JsonArray array = getJArray(json, "_targetProfile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getTargetProfile().size())
          res.getTargetProfile().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getTargetProfile().get(i));
      }
    };
    if (json.has("aggregation")) {
      JsonArray array = getJArray(json, "aggregation");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getAggregation().add(new Enumeration<ElementDefinition.AggregationMode>(new ElementDefinition.AggregationModeEnumFactory(), ElementDefinition.AggregationMode.NULL));
        } else {;
          res.getAggregation().add(parseEnumeration(array.get(i).getAsString(), ElementDefinition.AggregationMode.NULL, new ElementDefinition.AggregationModeEnumFactory()));
        }
      }
    };
    if (json.has("_aggregation")) {
      JsonArray array = getJArray(json, "_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));
      }
    };
    if (json.has("versioning"))
      res.setVersioningElement(parseEnumeration(json.get("versioning").getAsString(), ElementDefinition.ReferenceVersionRules.NULL, new ElementDefinition.ReferenceVersionRulesEnumFactory()));
    if (json.has("_versioning"))
      parseElementProperties(getJObject(json, "_versioning"), res.getVersioningElement());
  }

  protected ElementDefinition.ElementDefinitionExampleComponent parseElementDefinitionExampleComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionExampleComponent res = new ElementDefinition.ElementDefinitionExampleComponent();
    parseElementDefinitionExampleComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionExampleComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionExampleComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(getJObject(json, "_label"), res.getLabelElement());
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected ElementDefinition.ElementDefinitionConstraintComponent parseElementDefinitionConstraintComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionConstraintComponent res = new ElementDefinition.ElementDefinitionConstraintComponent();
    parseElementDefinitionConstraintComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionConstraintComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionConstraintComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("key"))
      res.setKeyElement(parseId(json.get("key").getAsString()));
    if (json.has("_key"))
      parseElementProperties(getJObject(json, "_key"), res.getKeyElement());
    if (json.has("requirements"))
      res.setRequirementsElement(parseMarkdown(json.get("requirements").getAsString()));
    if (json.has("_requirements"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_severity"), res.getSeverityElement());
    if (json.has("suppress"))
      res.setSuppressElement(parseBoolean(json.get("suppress").getAsBoolean()));
    if (json.has("_suppress"))
      parseElementProperties(getJObject(json, "_suppress"), res.getSuppressElement());
    if (json.has("human"))
      res.setHumanElement(parseString(json.get("human").getAsString()));
    if (json.has("_human"))
      parseElementProperties(getJObject(json, "_human"), res.getHumanElement());
    if (json.has("expression"))
      res.setExpressionElement(parseString(json.get("expression").getAsString()));
    if (json.has("_expression"))
      parseElementProperties(getJObject(json, "_expression"), res.getExpressionElement());
    if (json.has("xpath"))
      res.setXpathElement(parseString(json.get("xpath").getAsString()));
    if (json.has("_xpath"))
      parseElementProperties(getJObject(json, "_xpath"), res.getXpathElement());
    if (json.has("source"))
      res.setSourceElement(parseCanonical(json.get("source").getAsString()));
    if (json.has("_source"))
      parseElementProperties(getJObject(json, "_source"), res.getSourceElement());
  }

  protected ElementDefinition.ElementDefinitionBindingComponent parseElementDefinitionBindingComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionBindingComponent res = new ElementDefinition.ElementDefinitionBindingComponent();
    parseElementDefinitionBindingComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionBindingComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionBindingComponent res) throws IOException, FHIRFormatError {
    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(getJObject(json, "_strength"), res.getStrengthElement());
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("valueSet"))
      res.setValueSetElement(parseCanonical(json.get("valueSet").getAsString()));
    if (json.has("_valueSet"))
      parseElementProperties(getJObject(json, "_valueSet"), res.getValueSetElement());
  }

  protected ElementDefinition.ElementDefinitionMappingComponent parseElementDefinitionMappingComponent(JsonObject json) throws IOException, FHIRFormatError {
    ElementDefinition.ElementDefinitionMappingComponent res = new ElementDefinition.ElementDefinitionMappingComponent();
    parseElementDefinitionMappingComponentProperties(json, res);
    return res;
  }

  protected void parseElementDefinitionMappingComponentProperties(JsonObject json, ElementDefinition.ElementDefinitionMappingComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    if (json.has("identity"))
      res.setIdentityElement(parseId(json.get("identity").getAsString()));
    if (json.has("_identity"))
      parseElementProperties(getJObject(json, "_identity"), res.getIdentityElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(getJObject(json, "_language"), res.getLanguageElement());
    if (json.has("map"))
      res.setMapElement(parseString(json.get("map").getAsString()));
    if (json.has("_map"))
      parseElementProperties(getJObject(json, "_map"), res.getMapElement());
    if (json.has("comment"))
      res.setCommentElement(parseMarkdown(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(getJObject(json, "_comment"), res.getCommentElement());
  }

  protected Expression parseExpression(JsonObject json) throws IOException, FHIRFormatError {
    Expression res = new Expression();
    parseExpressionProperties(json, res);
    return res;
  }

  protected void parseExpressionProperties(JsonObject json, Expression res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("name"))
      res.setNameElement(parseId(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(getJObject(json, "_language"), res.getLanguageElement());
    if (json.has("expression"))
      res.setExpressionElement(parseString(json.get("expression").getAsString()));
    if (json.has("_expression"))
      parseElementProperties(getJObject(json, "_expression"), res.getExpressionElement());
    if (json.has("reference"))
      res.setReferenceElement(parseUri(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(getJObject(json, "_reference"), res.getReferenceElement());
  }

  protected ExtendedContactDetail parseExtendedContactDetail(JsonObject json) throws IOException, FHIRFormatError {
    ExtendedContactDetail res = new ExtendedContactDetail();
    parseExtendedContactDetailProperties(json, res);
    return res;
  }

  protected void parseExtendedContactDetailProperties(JsonObject json, ExtendedContactDetail res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("purpose"))
      res.setPurpose(parseCodeableConcept(getJObject(json, "purpose")));
    if (json.has("name")) {
      JsonArray array = getJArray(json, "name");
      for (int i = 0; i < array.size(); i++) {
        res.getName().add(parseHumanName(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("telecom")) {
      JsonArray array = getJArray(json, "telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("address"))
      res.setAddress(parseAddress(getJObject(json, "address")));
    if (json.has("organization"))
      res.setOrganization(parseReference(getJObject(json, "organization")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Extension parseExtension(JsonObject json) throws IOException, FHIRFormatError {
    Extension res = new Extension();
    parseExtensionProperties(json, res);
    return res;
  }

  protected void parseExtensionProperties(JsonObject json, Extension res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected HumanName parseHumanName(JsonObject json) throws IOException, FHIRFormatError {
    HumanName res = new HumanName();
    parseHumanNameProperties(json, res);
    return res;
  }

  protected void parseHumanNameProperties(JsonObject json, HumanName res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), HumanName.NameUse.NULL, new HumanName.NameUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(getJObject(json, "_use"), res.getUseElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
    if (json.has("family"))
      res.setFamilyElement(parseString(json.get("family").getAsString()));
    if (json.has("_family"))
      parseElementProperties(getJObject(json, "_family"), res.getFamilyElement());
    if (json.has("given")) {
      JsonArray array = getJArray(json, "given");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getGiven().add(new StringType());
        } else {;
          res.getGiven().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_given")) {
      JsonArray array = getJArray(json, "_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 = getJArray(json, "prefix");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPrefix().add(new StringType());
        } else {;
          res.getPrefix().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_prefix")) {
      JsonArray array = getJArray(json, "_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 = getJArray(json, "suffix");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSuffix().add(new StringType());
        } else {;
          res.getSuffix().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_suffix")) {
      JsonArray array = getJArray(json, "_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(getJObject(json, "period")));
  }

  protected Identifier parseIdentifier(JsonObject json) throws IOException, FHIRFormatError {
    Identifier res = new Identifier();
    parseIdentifierProperties(json, res);
    return res;
  }

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

  protected MarketingStatus parseMarketingStatus(JsonObject json) throws IOException, FHIRFormatError {
    MarketingStatus res = new MarketingStatus();
    parseMarketingStatusProperties(json, res);
    return res;
  }

  protected void parseMarketingStatusProperties(JsonObject json, MarketingStatus res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    if (json.has("country"))
      res.setCountry(parseCodeableConcept(getJObject(json, "country")));
    if (json.has("jurisdiction"))
      res.setJurisdiction(parseCodeableConcept(getJObject(json, "jurisdiction")));
    if (json.has("status"))
      res.setStatus(parseCodeableConcept(getJObject(json, "status")));
    if (json.has("dateRange"))
      res.setDateRange(parsePeriod(getJObject(json, "dateRange")));
    if (json.has("restoreDate"))
      res.setRestoreDateElement(parseDateTime(json.get("restoreDate").getAsString()));
    if (json.has("_restoreDate"))
      parseElementProperties(getJObject(json, "_restoreDate"), res.getRestoreDateElement());
  }

  protected Meta parseMeta(JsonObject json) throws IOException, FHIRFormatError {
    Meta res = new Meta();
    parseMetaProperties(json, res);
    return res;
  }

  protected void parseMetaProperties(JsonObject json, Meta res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("versionId"))
      res.setVersionIdElement(parseId(json.get("versionId").getAsString()));
    if (json.has("_versionId"))
      parseElementProperties(getJObject(json, "_versionId"), res.getVersionIdElement());
    if (json.has("lastUpdated"))
      res.setLastUpdatedElement(parseInstant(json.get("lastUpdated").getAsString()));
    if (json.has("_lastUpdated"))
      parseElementProperties(getJObject(json, "_lastUpdated"), res.getLastUpdatedElement());
    if (json.has("source"))
      res.setSourceElement(parseUri(json.get("source").getAsString()));
    if (json.has("_source"))
      parseElementProperties(getJObject(json, "_source"), res.getSourceElement());
    if (json.has("profile")) {
      JsonArray array = getJArray(json, "profile");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getProfile().add(new CanonicalType());
        } else {;
          res.getProfile().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_profile")) {
      JsonArray array = getJArray(json, "_profile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProfile().size())
          res.getProfile().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProfile().get(i));
      }
    };
    if (json.has("security")) {
      JsonArray array = getJArray(json, "security");
      for (int i = 0; i < array.size(); i++) {
        res.getSecurity().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("tag")) {
      JsonArray array = getJArray(json, "tag");
      for (int i = 0; i < array.size(); i++) {
        res.getTag().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected MonetaryComponent parseMonetaryComponent(JsonObject json) throws IOException, FHIRFormatError {
    MonetaryComponent res = new MonetaryComponent();
    parseMonetaryComponentProperties(json, res);
    return res;
  }

  protected void parseMonetaryComponentProperties(JsonObject json, MonetaryComponent res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), MonetaryComponent.PriceComponentType.NULL, new MonetaryComponent.PriceComponentTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("amount"))
      res.setAmount(parseMoney(getJObject(json, "amount")));
  }

  protected Money parseMoney(JsonObject json) throws IOException, FHIRFormatError {
    Money res = new Money();
    parseMoneyProperties(json, res);
    return res;
  }

  protected void parseMoneyProperties(JsonObject json, Money res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
    if (json.has("currency"))
      res.setCurrencyElement(parseCode(json.get("currency").getAsString()));
    if (json.has("_currency"))
      parseElementProperties(getJObject(json, "_currency"), res.getCurrencyElement());
  }

  protected Narrative parseNarrative(JsonObject json) throws IOException, FHIRFormatError {
    Narrative res = new Narrative();
    parseNarrativeProperties(json, res);
    return res;
  }

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

  protected ParameterDefinition parseParameterDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ParameterDefinition res = new ParameterDefinition();
    parseParameterDefinitionProperties(json, res);
    return res;
  }

  protected void parseParameterDefinitionProperties(JsonObject json, ParameterDefinition res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseCode(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Enumerations.OperationParameterUse.NULL, new Enumerations.OperationParameterUseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(getJObject(json, "_use"), res.getUseElement());
    if (json.has("min"))
      res.setMinElement(parseInteger(json.get("min").getAsLong()));
    if (json.has("_min"))
      parseElementProperties(getJObject(json, "_min"), res.getMinElement());
    if (json.has("max"))
      res.setMaxElement(parseString(json.get("max").getAsString()));
    if (json.has("_max"))
      parseElementProperties(getJObject(json, "_max"), res.getMaxElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.FHIRTypes.NULL, new Enumerations.FHIRTypesEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("profile"))
      res.setProfileElement(parseCanonical(json.get("profile").getAsString()));
    if (json.has("_profile"))
      parseElementProperties(getJObject(json, "_profile"), res.getProfileElement());
  }

  protected Period parsePeriod(JsonObject json) throws IOException, FHIRFormatError {
    Period res = new Period();
    parsePeriodProperties(json, res);
    return res;
  }

  protected void parsePeriodProperties(JsonObject json, Period res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("start"))
      res.setStartElement(parseDateTime(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(getJObject(json, "_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseDateTime(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(getJObject(json, "_end"), res.getEndElement());
  }

  protected Population parsePopulation(JsonObject json) throws IOException, FHIRFormatError {
    Population res = new Population();
    parsePopulationProperties(json, res);
    return res;
  }

  protected void parsePopulationProperties(JsonObject json, Population res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    DataType age = parseType("age", json);
    if (age != null)
      res.setAge(age);
    if (json.has("gender"))
      res.setGender(parseCodeableConcept(getJObject(json, "gender")));
    if (json.has("race"))
      res.setRace(parseCodeableConcept(getJObject(json, "race")));
    if (json.has("physiologicalCondition"))
      res.setPhysiologicalCondition(parseCodeableConcept(getJObject(json, "physiologicalCondition")));
  }

  protected ProductShelfLife parseProductShelfLife(JsonObject json) throws IOException, FHIRFormatError {
    ProductShelfLife res = new ProductShelfLife();
    parseProductShelfLifeProperties(json, res);
    return res;
  }

  protected void parseProductShelfLifeProperties(JsonObject json, ProductShelfLife res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    DataType period = parseType("period", json);
    if (period != null)
      res.setPeriod(period);
    if (json.has("specialPrecautionsForStorage")) {
      JsonArray array = getJArray(json, "specialPrecautionsForStorage");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialPrecautionsForStorage().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Quantity parseQuantity(JsonObject json) throws IOException, FHIRFormatError {
    Quantity res = new Quantity();
    parseQuantityProperties(json, res);
    return res;
  }

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

  protected Range parseRange(JsonObject json) throws IOException, FHIRFormatError {
    Range res = new Range();
    parseRangeProperties(json, res);
    return res;
  }

  protected void parseRangeProperties(JsonObject json, Range res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("low"))
      res.setLow(parseQuantity(getJObject(json, "low")));
    if (json.has("high"))
      res.setHigh(parseQuantity(getJObject(json, "high")));
  }

  protected Ratio parseRatio(JsonObject json) throws IOException, FHIRFormatError {
    Ratio res = new Ratio();
    parseRatioProperties(json, res);
    return res;
  }

  protected void parseRatioProperties(JsonObject json, Ratio res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("numerator"))
      res.setNumerator(parseQuantity(getJObject(json, "numerator")));
    if (json.has("denominator"))
      res.setDenominator(parseQuantity(getJObject(json, "denominator")));
  }

  protected RatioRange parseRatioRange(JsonObject json) throws IOException, FHIRFormatError {
    RatioRange res = new RatioRange();
    parseRatioRangeProperties(json, res);
    return res;
  }

  protected void parseRatioRangeProperties(JsonObject json, RatioRange res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("lowNumerator"))
      res.setLowNumerator(parseQuantity(getJObject(json, "lowNumerator")));
    if (json.has("highNumerator"))
      res.setHighNumerator(parseQuantity(getJObject(json, "highNumerator")));
    if (json.has("denominator"))
      res.setDenominator(parseQuantity(getJObject(json, "denominator")));
  }

  protected Reference parseReference(JsonObject json) throws IOException, FHIRFormatError {
    Reference res = new Reference();
    parseReferenceProperties(json, res);
    return res;
  }

  protected void parseReferenceProperties(JsonObject json, Reference res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("reference"))
      res.setReferenceElement(parseString(json.get("reference").getAsString()));
    if (json.has("_reference"))
      parseElementProperties(getJObject(json, "_reference"), res.getReferenceElement());
    if (json.has("type"))
      res.setTypeElement(parseUri(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(getJObject(json, "identifier")));
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(getJObject(json, "_display"), res.getDisplayElement());
  }

  protected RelatedArtifact parseRelatedArtifact(JsonObject json) throws IOException, FHIRFormatError {
    RelatedArtifact res = new RelatedArtifact();
    parseRelatedArtifactProperties(json, res);
    return res;
  }

  protected void parseRelatedArtifactProperties(JsonObject json, RelatedArtifact res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), RelatedArtifact.RelatedArtifactType.NULL, new RelatedArtifact.RelatedArtifactTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(getJObject(json, "_label"), res.getLabelElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(getJObject(json, "_display"), res.getDisplayElement());
    if (json.has("citation"))
      res.setCitationElement(parseMarkdown(json.get("citation").getAsString()));
    if (json.has("_citation"))
      parseElementProperties(getJObject(json, "_citation"), res.getCitationElement());
    if (json.has("document"))
      res.setDocument(parseAttachment(getJObject(json, "document")));
    if (json.has("resource"))
      res.setResourceElement(parseCanonical(json.get("resource").getAsString()));
    if (json.has("_resource"))
      parseElementProperties(getJObject(json, "_resource"), res.getResourceElement());
    if (json.has("resourceReference"))
      res.setResourceReference(parseReference(getJObject(json, "resourceReference")));
    if (json.has("publicationStatus"))
      res.setPublicationStatusElement(parseEnumeration(json.get("publicationStatus").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_publicationStatus"))
      parseElementProperties(getJObject(json, "_publicationStatus"), res.getPublicationStatusElement());
    if (json.has("publicationDate"))
      res.setPublicationDateElement(parseDate(json.get("publicationDate").getAsString()));
    if (json.has("_publicationDate"))
      parseElementProperties(getJObject(json, "_publicationDate"), res.getPublicationDateElement());
  }

  protected SampledData parseSampledData(JsonObject json) throws IOException, FHIRFormatError {
    SampledData res = new SampledData();
    parseSampledDataProperties(json, res);
    return res;
  }

  protected void parseSampledDataProperties(JsonObject json, SampledData res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("origin"))
      res.setOrigin(parseQuantity(getJObject(json, "origin")));
    if (json.has("interval"))
      res.setIntervalElement(parseDecimal(json.get("interval").getAsBigDecimal()));
    if (json.has("_interval"))
      parseElementProperties(getJObject(json, "_interval"), res.getIntervalElement());
    if (json.has("intervalUnit"))
      res.setIntervalUnitElement(parseCode(json.get("intervalUnit").getAsString()));
    if (json.has("_intervalUnit"))
      parseElementProperties(getJObject(json, "_intervalUnit"), res.getIntervalUnitElement());
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("lowerLimit"))
      res.setLowerLimitElement(parseDecimal(json.get("lowerLimit").getAsBigDecimal()));
    if (json.has("_lowerLimit"))
      parseElementProperties(getJObject(json, "_lowerLimit"), res.getLowerLimitElement());
    if (json.has("upperLimit"))
      res.setUpperLimitElement(parseDecimal(json.get("upperLimit").getAsBigDecimal()));
    if (json.has("_upperLimit"))
      parseElementProperties(getJObject(json, "_upperLimit"), res.getUpperLimitElement());
    if (json.has("dimensions"))
      res.setDimensionsElement(parsePositiveInt(json.get("dimensions").getAsString()));
    if (json.has("_dimensions"))
      parseElementProperties(getJObject(json, "_dimensions"), res.getDimensionsElement());
    if (json.has("data"))
      res.setDataElement(parseString(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(getJObject(json, "_data"), res.getDataElement());
  }

  protected Signature parseSignature(JsonObject json) throws IOException, FHIRFormatError {
    Signature res = new Signature();
    parseSignatureProperties(json, res);
    return res;
  }

  protected void parseSignatureProperties(JsonObject json, Signature res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_when"), res.getWhenElement());
    if (json.has("who"))
      res.setWho(parseReference(getJObject(json, "who")));
    if (json.has("onBehalfOf"))
      res.setOnBehalfOf(parseReference(getJObject(json, "onBehalfOf")));
    if (json.has("targetFormat"))
      res.setTargetFormatElement(parseCode(json.get("targetFormat").getAsString()));
    if (json.has("_targetFormat"))
      parseElementProperties(getJObject(json, "_targetFormat"), res.getTargetFormatElement());
    if (json.has("sigFormat"))
      res.setSigFormatElement(parseCode(json.get("sigFormat").getAsString()));
    if (json.has("_sigFormat"))
      parseElementProperties(getJObject(json, "_sigFormat"), res.getSigFormatElement());
    if (json.has("data"))
      res.setDataElement(parseBase64Binary(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(getJObject(json, "_data"), res.getDataElement());
  }

  protected Timing parseTiming(JsonObject json) throws IOException, FHIRFormatError {
    Timing res = new Timing();
    parseTimingProperties(json, res);
    return res;
  }

  protected void parseTimingProperties(JsonObject json, Timing res) throws IOException, FHIRFormatError {
    parseBackboneTypeProperties(json, res);
    if (json.has("event")) {
      JsonArray array = getJArray(json, "event");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getEvent().add(new DateTimeType());
        } else {;
          res.getEvent().add(parseDateTime(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_event")) {
      JsonArray array = getJArray(json, "_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(parseTimingRepeatComponent(getJObject(json, "repeat")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
  }

  protected Timing.TimingRepeatComponent parseTimingRepeatComponent(JsonObject json) throws IOException, FHIRFormatError {
    Timing.TimingRepeatComponent res = new Timing.TimingRepeatComponent();
    parseTimingRepeatComponentProperties(json, res);
    return res;
  }

  protected void parseTimingRepeatComponentProperties(JsonObject json, Timing.TimingRepeatComponent res) throws IOException, FHIRFormatError {
    parseElementProperties(json, res);
    DataType bounds = parseType("bounds", json);
    if (bounds != null)
      res.setBounds(bounds);
    if (json.has("count"))
      res.setCountElement(parsePositiveInt(json.get("count").getAsString()));
    if (json.has("_count"))
      parseElementProperties(getJObject(json, "_count"), res.getCountElement());
    if (json.has("countMax"))
      res.setCountMaxElement(parsePositiveInt(json.get("countMax").getAsString()));
    if (json.has("_countMax"))
      parseElementProperties(getJObject(json, "_countMax"), res.getCountMaxElement());
    if (json.has("duration"))
      res.setDurationElement(parseDecimal(json.get("duration").getAsBigDecimal()));
    if (json.has("_duration"))
      parseElementProperties(getJObject(json, "_duration"), res.getDurationElement());
    if (json.has("durationMax"))
      res.setDurationMaxElement(parseDecimal(json.get("durationMax").getAsBigDecimal()));
    if (json.has("_durationMax"))
      parseElementProperties(getJObject(json, "_durationMax"), res.getDurationMaxElement());
    if (json.has("durationUnit"))
      res.setDurationUnitElement(parseEnumeration(json.get("durationUnit").getAsString(), Timing.UnitsOfTime.NULL, new Timing.UnitsOfTimeEnumFactory()));
    if (json.has("_durationUnit"))
      parseElementProperties(getJObject(json, "_durationUnit"), res.getDurationUnitElement());
    if (json.has("frequency"))
      res.setFrequencyElement(parsePositiveInt(json.get("frequency").getAsString()));
    if (json.has("_frequency"))
      parseElementProperties(getJObject(json, "_frequency"), res.getFrequencyElement());
    if (json.has("frequencyMax"))
      res.setFrequencyMaxElement(parsePositiveInt(json.get("frequencyMax").getAsString()));
    if (json.has("_frequencyMax"))
      parseElementProperties(getJObject(json, "_frequencyMax"), res.getFrequencyMaxElement());
    if (json.has("period"))
      res.setPeriodElement(parseDecimal(json.get("period").getAsBigDecimal()));
    if (json.has("_period"))
      parseElementProperties(getJObject(json, "_period"), res.getPeriodElement());
    if (json.has("periodMax"))
      res.setPeriodMaxElement(parseDecimal(json.get("periodMax").getAsBigDecimal()));
    if (json.has("_periodMax"))
      parseElementProperties(getJObject(json, "_periodMax"), res.getPeriodMaxElement());
    if (json.has("periodUnit"))
      res.setPeriodUnitElement(parseEnumeration(json.get("periodUnit").getAsString(), Timing.UnitsOfTime.NULL, new Timing.UnitsOfTimeEnumFactory()));
    if (json.has("_periodUnit"))
      parseElementProperties(getJObject(json, "_periodUnit"), res.getPeriodUnitElement());
    if (json.has("dayOfWeek")) {
      JsonArray array = getJArray(json, "dayOfWeek");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDayOfWeek().add(new Enumeration<Enumerations.DaysOfWeek>(new Enumerations.DaysOfWeekEnumFactory(), Enumerations.DaysOfWeek.NULL));
        } else {;
          res.getDayOfWeek().add(parseEnumeration(array.get(i).getAsString(), Enumerations.DaysOfWeek.NULL, new Enumerations.DaysOfWeekEnumFactory()));
        }
      }
    };
    if (json.has("_dayOfWeek")) {
      JsonArray array = getJArray(json, "_dayOfWeek");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDayOfWeek().size())
          res.getDayOfWeek().add(parseEnumeration(null, Enumerations.DaysOfWeek.NULL, new Enumerations.DaysOfWeekEnumFactory()));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDayOfWeek().get(i));
      }
    };
    if (json.has("timeOfDay")) {
      JsonArray array = getJArray(json, "timeOfDay");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getTimeOfDay().add(new TimeType());
        } else {;
          res.getTimeOfDay().add(parseTime(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_timeOfDay")) {
      JsonArray array = getJArray(json, "_timeOfDay");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getTimeOfDay().size())
          res.getTimeOfDay().add(parseTime(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getTimeOfDay().get(i));
      }
    };
    if (json.has("when")) {
      JsonArray array = getJArray(json, "when");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getWhen().add(new Enumeration<Timing.EventTiming>(new Timing.EventTimingEnumFactory(), Timing.EventTiming.NULL));
        } else {;
          res.getWhen().add(parseEnumeration(array.get(i).getAsString(), Timing.EventTiming.NULL, new Timing.EventTimingEnumFactory()));
        }
      }
    };
    if (json.has("_when")) {
      JsonArray array = getJArray(json, "_when");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getWhen().size())
          res.getWhen().add(parseEnumeration(null, Timing.EventTiming.NULL, new Timing.EventTimingEnumFactory()));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getWhen().get(i));
      }
    };
    if (json.has("offset"))
      res.setOffsetElement(parseUnsignedInt(json.get("offset").getAsString()));
    if (json.has("_offset"))
      parseElementProperties(getJObject(json, "_offset"), res.getOffsetElement());
  }

  protected TriggerDefinition parseTriggerDefinition(JsonObject json) throws IOException, FHIRFormatError {
    TriggerDefinition res = new TriggerDefinition();
    parseTriggerDefinitionProperties(json, res);
    return res;
  }

  protected void parseTriggerDefinitionProperties(JsonObject json, TriggerDefinition res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), TriggerDefinition.TriggerType.NULL, new TriggerDefinition.TriggerTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("subscriptionTopic"))
      res.setSubscriptionTopicElement(parseCanonical(json.get("subscriptionTopic").getAsString()));
    if (json.has("_subscriptionTopic"))
      parseElementProperties(getJObject(json, "_subscriptionTopic"), res.getSubscriptionTopicElement());
    DataType timing = parseType("timing", json);
    if (timing != null)
      res.setTiming(timing);
    if (json.has("data")) {
      JsonArray array = getJArray(json, "data");
      for (int i = 0; i < array.size(); i++) {
        res.getData().add(parseDataRequirement(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("condition"))
      res.setCondition(parseExpression(getJObject(json, "condition")));
  }

  protected UsageContext parseUsageContext(JsonObject json) throws IOException, FHIRFormatError {
    UsageContext res = new UsageContext();
    parseUsageContextProperties(json, res);
    return res;
  }

  protected void parseUsageContextProperties(JsonObject json, UsageContext res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(getJObject(json, "code")));
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected VirtualServiceDetail parseVirtualServiceDetail(JsonObject json) throws IOException, FHIRFormatError {
    VirtualServiceDetail res = new VirtualServiceDetail();
    parseVirtualServiceDetailProperties(json, res);
    return res;
  }

  protected void parseVirtualServiceDetailProperties(JsonObject json, VirtualServiceDetail res) throws IOException, FHIRFormatError {
    parseDataTypeProperties(json, res);
    if (json.has("channelType"))
      res.setChannelType(parseCoding(getJObject(json, "channelType")));
    DataType address = parseType("address", json);
    if (address != null)
      res.setAddress(address);
    if (json.has("additionalInfo")) {
      JsonArray array = getJArray(json, "additionalInfo");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getAdditionalInfo().add(new UrlType());
        } else {;
          res.getAdditionalInfo().add(parseUrl(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_additionalInfo")) {
      JsonArray array = getJArray(json, "_additionalInfo");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getAdditionalInfo().size())
          res.getAdditionalInfo().add(parseUrl(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getAdditionalInfo().get(i));
      }
    };
    if (json.has("maxParticipants"))
      res.setMaxParticipantsElement(parsePositiveInt(json.get("maxParticipants").getAsString()));
    if (json.has("_maxParticipants"))
      parseElementProperties(getJObject(json, "_maxParticipants"), res.getMaxParticipantsElement());
    if (json.has("sessionKey"))
      res.setSessionKeyElement(parseString(json.get("sessionKey").getAsString()));
    if (json.has("_sessionKey"))
      parseElementProperties(getJObject(json, "_sessionKey"), res.getSessionKeyElement());
  }

  protected void parseCanonicalResourceProperties(JsonObject json, CanonicalResource res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
  }

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

  protected void parseMetadataResourceProperties(JsonObject json, MetadataResource res) throws IOException, FHIRFormatError {
    parseCanonicalResourceProperties(json, res);
  }

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

  protected Account parseAccount(JsonObject json) throws IOException, FHIRFormatError {
    Account res = new Account();
    parseAccountProperties(json, res);
    return res;
  }

  protected void parseAccountProperties(JsonObject json, Account res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), Account.AccountStatus.NULL, new Account.AccountStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("billingStatus"))
      res.setBillingStatus(parseCodeableConcept(getJObject(json, "billingStatus")));
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("subject")) {
      JsonArray array = getJArray(json, "subject");
      for (int i = 0; i < array.size(); i++) {
        res.getSubject().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("servicePeriod"))
      res.setServicePeriod(parsePeriod(getJObject(json, "servicePeriod")));
    if (json.has("coverage")) {
      JsonArray array = getJArray(json, "coverage");
      for (int i = 0; i < array.size(); i++) {
        res.getCoverage().add(parseAccountCoverageComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("owner"))
      res.setOwner(parseReference(getJObject(json, "owner")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("guarantor")) {
      JsonArray array = getJArray(json, "guarantor");
      for (int i = 0; i < array.size(); i++) {
        res.getGuarantor().add(parseAccountGuarantorComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("relatedAccount")) {
      JsonArray array = getJArray(json, "relatedAccount");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedAccount().add(parseAccountRelatedAccountComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("currency"))
      res.setCurrency(parseCodeableConcept(getJObject(json, "currency")));
    if (json.has("balance")) {
      JsonArray array = getJArray(json, "balance");
      for (int i = 0; i < array.size(); i++) {
        res.getBalance().add(parseAccountBalanceComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("calculatedAt"))
      res.setCalculatedAtElement(parseInstant(json.get("calculatedAt").getAsString()));
    if (json.has("_calculatedAt"))
      parseElementProperties(getJObject(json, "_calculatedAt"), res.getCalculatedAtElement());
  }

  protected Account.CoverageComponent parseAccountCoverageComponent(JsonObject json) throws IOException, FHIRFormatError {
    Account.CoverageComponent res = new Account.CoverageComponent();
    parseAccountCoverageComponentProperties(json, res);
    return res;
  }

  protected void parseAccountCoverageComponentProperties(JsonObject json, Account.CoverageComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("coverage"))
      res.setCoverage(parseReference(getJObject(json, "coverage")));
    if (json.has("priority"))
      res.setPriorityElement(parsePositiveInt(json.get("priority").getAsString()));
    if (json.has("_priority"))
      parseElementProperties(getJObject(json, "_priority"), res.getPriorityElement());
  }

  protected Account.GuarantorComponent parseAccountGuarantorComponent(JsonObject json) throws IOException, FHIRFormatError {
    Account.GuarantorComponent res = new Account.GuarantorComponent();
    parseAccountGuarantorComponentProperties(json, res);
    return res;
  }

  protected void parseAccountGuarantorComponentProperties(JsonObject json, Account.GuarantorComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("party"))
      res.setParty(parseReference(getJObject(json, "party")));
    if (json.has("onHold"))
      res.setOnHoldElement(parseBoolean(json.get("onHold").getAsBoolean()));
    if (json.has("_onHold"))
      parseElementProperties(getJObject(json, "_onHold"), res.getOnHoldElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Account.AccountRelatedAccountComponent parseAccountRelatedAccountComponent(JsonObject json) throws IOException, FHIRFormatError {
    Account.AccountRelatedAccountComponent res = new Account.AccountRelatedAccountComponent();
    parseAccountRelatedAccountComponentProperties(json, res);
    return res;
  }

  protected void parseAccountRelatedAccountComponentProperties(JsonObject json, Account.AccountRelatedAccountComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("relationship"))
      res.setRelationship(parseCodeableConcept(getJObject(json, "relationship")));
    if (json.has("account"))
      res.setAccount(parseReference(getJObject(json, "account")));
  }

  protected Account.AccountBalanceComponent parseAccountBalanceComponent(JsonObject json) throws IOException, FHIRFormatError {
    Account.AccountBalanceComponent res = new Account.AccountBalanceComponent();
    parseAccountBalanceComponentProperties(json, res);
    return res;
  }

  protected void parseAccountBalanceComponentProperties(JsonObject json, Account.AccountBalanceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("aggregate"))
      res.setAggregate(parseCodeableConcept(getJObject(json, "aggregate")));
    if (json.has("term"))
      res.setTerm(parseCodeableConcept(getJObject(json, "term")));
    if (json.has("estimate"))
      res.setEstimateElement(parseBoolean(json.get("estimate").getAsBoolean()));
    if (json.has("_estimate"))
      parseElementProperties(getJObject(json, "_estimate"), res.getEstimateElement());
    if (json.has("amount"))
      res.setAmount(parseMoney(getJObject(json, "amount")));
  }

  protected ActivityDefinition parseActivityDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ActivityDefinition res = new ActivityDefinition();
    parseActivityDefinitionProperties(json, res);
    return res;
  }

  protected void parseActivityDefinitionProperties(JsonObject json, ActivityDefinition res) throws IOException, FHIRFormatError {
    parseMetadataResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("subtitle"))
      res.setSubtitleElement(parseString(json.get("subtitle").getAsString()));
    if (json.has("_subtitle"))
      parseElementProperties(getJObject(json, "_subtitle"), res.getSubtitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    DataType subject = parseType("subject", json);
    if (subject != null)
      res.setSubject(subject);
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("usage"))
      res.setUsageElement(parseString(json.get("usage").getAsString()));
    if (json.has("_usage"))
      parseElementProperties(getJObject(json, "_usage"), res.getUsageElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("approvalDate"))
      res.setApprovalDateElement(parseDate(json.get("approvalDate").getAsString()));
    if (json.has("_approvalDate"))
      parseElementProperties(getJObject(json, "_approvalDate"), res.getApprovalDateElement());
    if (json.has("lastReviewDate"))
      res.setLastReviewDateElement(parseDate(json.get("lastReviewDate").getAsString()));
    if (json.has("_lastReviewDate"))
      parseElementProperties(getJObject(json, "_lastReviewDate"), res.getLastReviewDateElement());
    if (json.has("effectivePeriod"))
      res.setEffectivePeriod(parsePeriod(getJObject(json, "effectivePeriod")));
    if (json.has("topic")) {
      JsonArray array = getJArray(json, "topic");
      for (int i = 0; i < array.size(); i++) {
        res.getTopic().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("author")) {
      JsonArray array = getJArray(json, "author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("editor")) {
      JsonArray array = getJArray(json, "editor");
      for (int i = 0; i < array.size(); i++) {
        res.getEditor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reviewer")) {
      JsonArray array = getJArray(json, "reviewer");
      for (int i = 0; i < array.size(); i++) {
        res.getReviewer().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("endorser")) {
      JsonArray array = getJArray(json, "endorser");
      for (int i = 0; i < array.size(); i++) {
        res.getEndorser().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("relatedArtifact")) {
      JsonArray array = getJArray(json, "relatedArtifact");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedArtifact().add(parseRelatedArtifact(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("library")) {
      JsonArray array = getJArray(json, "library");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getLibrary().add(new CanonicalType());
        } else {;
          res.getLibrary().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_library")) {
      JsonArray array = getJArray(json, "_library");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getLibrary().size())
          res.getLibrary().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getLibrary().get(i));
      }
    };
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), ActivityDefinition.RequestResourceTypes.NULL, new ActivityDefinition.RequestResourceTypesEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(getJObject(json, "_kind"), res.getKindElement());
    if (json.has("profile"))
      res.setProfileElement(parseCanonical(json.get("profile").getAsString()));
    if (json.has("_profile"))
      parseElementProperties(getJObject(json, "_profile"), res.getProfileElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("intent"))
      res.setIntentElement(parseEnumeration(json.get("intent").getAsString(), Enumerations.RequestIntent.NULL, new Enumerations.RequestIntentEnumFactory()));
    if (json.has("_intent"))
      parseElementProperties(getJObject(json, "_intent"), res.getIntentElement());
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(), Enumerations.RequestPriority.NULL, new Enumerations.RequestPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(getJObject(json, "_priority"), res.getPriorityElement());
    if (json.has("doNotPerform"))
      res.setDoNotPerformElement(parseBoolean(json.get("doNotPerform").getAsBoolean()));
    if (json.has("_doNotPerform"))
      parseElementProperties(getJObject(json, "_doNotPerform"), res.getDoNotPerformElement());
    DataType timing = parseType("timing", json);
    if (timing != null)
      res.setTiming(timing);
    DataType asNeeded = parseType("asNeeded", json);
    if (asNeeded != null)
      res.setAsNeeded(asNeeded);
    if (json.has("location"))
      res.setLocation(parseCodeableReference(getJObject(json, "location")));
    if (json.has("participant")) {
      JsonArray array = getJArray(json, "participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseActivityDefinitionParticipantComponent(array.get(i).getAsJsonObject()));
      }
    };
    DataType product = parseType("product", json);
    if (product != null)
      res.setProduct(product);
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("dosage")) {
      JsonArray array = getJArray(json, "dosage");
      for (int i = 0; i < array.size(); i++) {
        res.getDosage().add(parseDosage(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("bodySite")) {
      JsonArray array = getJArray(json, "bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("specimenRequirement")) {
      JsonArray array = getJArray(json, "specimenRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSpecimenRequirement().add(new CanonicalType());
        } else {;
          res.getSpecimenRequirement().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_specimenRequirement")) {
      JsonArray array = getJArray(json, "_specimenRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSpecimenRequirement().size())
          res.getSpecimenRequirement().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSpecimenRequirement().get(i));
      }
    };
    if (json.has("observationRequirement")) {
      JsonArray array = getJArray(json, "observationRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getObservationRequirement().add(new CanonicalType());
        } else {;
          res.getObservationRequirement().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_observationRequirement")) {
      JsonArray array = getJArray(json, "_observationRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getObservationRequirement().size())
          res.getObservationRequirement().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getObservationRequirement().get(i));
      }
    };
    if (json.has("observationResultRequirement")) {
      JsonArray array = getJArray(json, "observationResultRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getObservationResultRequirement().add(new CanonicalType());
        } else {;
          res.getObservationResultRequirement().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_observationResultRequirement")) {
      JsonArray array = getJArray(json, "_observationResultRequirement");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getObservationResultRequirement().size())
          res.getObservationResultRequirement().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getObservationResultRequirement().get(i));
      }
    };
    if (json.has("transform"))
      res.setTransformElement(parseCanonical(json.get("transform").getAsString()));
    if (json.has("_transform"))
      parseElementProperties(getJObject(json, "_transform"), res.getTransformElement());
    if (json.has("dynamicValue")) {
      JsonArray array = getJArray(json, "dynamicValue");
      for (int i = 0; i < array.size(); i++) {
        res.getDynamicValue().add(parseActivityDefinitionDynamicValueComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ActivityDefinition.ActivityDefinitionParticipantComponent parseActivityDefinitionParticipantComponent(JsonObject json) throws IOException, FHIRFormatError {
    ActivityDefinition.ActivityDefinitionParticipantComponent res = new ActivityDefinition.ActivityDefinitionParticipantComponent();
    parseActivityDefinitionParticipantComponentProperties(json, res);
    return res;
  }

  protected void parseActivityDefinitionParticipantComponentProperties(JsonObject json, ActivityDefinition.ActivityDefinitionParticipantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.ActionParticipantType.NULL, new Enumerations.ActionParticipantTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("typeCanonical"))
      res.setTypeCanonicalElement(parseCanonical(json.get("typeCanonical").getAsString()));
    if (json.has("_typeCanonical"))
      parseElementProperties(getJObject(json, "_typeCanonical"), res.getTypeCanonicalElement());
    if (json.has("typeReference"))
      res.setTypeReference(parseReference(getJObject(json, "typeReference")));
    if (json.has("role"))
      res.setRole(parseCodeableConcept(getJObject(json, "role")));
    if (json.has("function"))
      res.setFunction(parseCodeableConcept(getJObject(json, "function")));
  }

  protected ActivityDefinition.ActivityDefinitionDynamicValueComponent parseActivityDefinitionDynamicValueComponent(JsonObject json) throws IOException, FHIRFormatError {
    ActivityDefinition.ActivityDefinitionDynamicValueComponent res = new ActivityDefinition.ActivityDefinitionDynamicValueComponent();
    parseActivityDefinitionDynamicValueComponentProperties(json, res);
    return res;
  }

  protected void parseActivityDefinitionDynamicValueComponentProperties(JsonObject json, ActivityDefinition.ActivityDefinitionDynamicValueComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("path"))
      res.setPathElement(parseString(json.get("path").getAsString()));
    if (json.has("_path"))
      parseElementProperties(getJObject(json, "_path"), res.getPathElement());
    if (json.has("expression"))
      res.setExpression(parseExpression(getJObject(json, "expression")));
  }

  protected ActorDefinition parseActorDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ActorDefinition res = new ActorDefinition();
    parseActorDefinitionProperties(json, res);
    return res;
  }

  protected void parseActorDefinitionProperties(JsonObject json, ActorDefinition res) throws IOException, FHIRFormatError {
    parseCanonicalResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("copyrightLabel"))
      res.setCopyrightLabelElement(parseString(json.get("copyrightLabel").getAsString()));
    if (json.has("_copyrightLabel"))
      parseElementProperties(getJObject(json, "_copyrightLabel"), res.getCopyrightLabelElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.ExampleScenarioActorType.NULL, new Enumerations.ExampleScenarioActorTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("reference")) {
      JsonArray array = getJArray(json, "reference");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getReference().add(new UrlType());
        } else {;
          res.getReference().add(parseUrl(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_reference")) {
      JsonArray array = getJArray(json, "_reference");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getReference().size())
          res.getReference().add(parseUrl(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getReference().get(i));
      }
    };
    if (json.has("capabilities"))
      res.setCapabilitiesElement(parseCanonical(json.get("capabilities").getAsString()));
    if (json.has("_capabilities"))
      parseElementProperties(getJObject(json, "_capabilities"), res.getCapabilitiesElement());
    if (json.has("derivedFrom")) {
      JsonArray array = getJArray(json, "derivedFrom");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDerivedFrom().add(new CanonicalType());
        } else {;
          res.getDerivedFrom().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_derivedFrom")) {
      JsonArray array = getJArray(json, "_derivedFrom");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDerivedFrom().size())
          res.getDerivedFrom().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDerivedFrom().get(i));
      }
    };
  }

  protected AdministrableProductDefinition parseAdministrableProductDefinition(JsonObject json) throws IOException, FHIRFormatError {
    AdministrableProductDefinition res = new AdministrableProductDefinition();
    parseAdministrableProductDefinitionProperties(json, res);
    return res;
  }

  protected void parseAdministrableProductDefinitionProperties(JsonObject json, AdministrableProductDefinition res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("formOf")) {
      JsonArray array = getJArray(json, "formOf");
      for (int i = 0; i < array.size(); i++) {
        res.getFormOf().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("administrableDoseForm"))
      res.setAdministrableDoseForm(parseCodeableConcept(getJObject(json, "administrableDoseForm")));
    if (json.has("unitOfPresentation"))
      res.setUnitOfPresentation(parseCodeableConcept(getJObject(json, "unitOfPresentation")));
    if (json.has("producedFrom")) {
      JsonArray array = getJArray(json, "producedFrom");
      for (int i = 0; i < array.size(); i++) {
        res.getProducedFrom().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("ingredient")) {
      JsonArray array = getJArray(json, "ingredient");
      for (int i = 0; i < array.size(); i++) {
        res.getIngredient().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("device"))
      res.setDevice(parseReference(getJObject(json, "device")));
    if (json.has("property")) {
      JsonArray array = getJArray(json, "property");
      for (int i = 0; i < array.size(); i++) {
        res.getProperty().add(parseAdministrableProductDefinitionPropertyComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("routeOfAdministration")) {
      JsonArray array = getJArray(json, "routeOfAdministration");
      for (int i = 0; i < array.size(); i++) {
        res.getRouteOfAdministration().add(parseAdministrableProductDefinitionRouteOfAdministrationComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent parseAdministrableProductDefinitionPropertyComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent res = new AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent();
    parseAdministrableProductDefinitionPropertyComponentProperties(json, res);
    return res;
  }

  protected void parseAdministrableProductDefinitionPropertyComponentProperties(JsonObject json, AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("status"))
      res.setStatus(parseCodeableConcept(getJObject(json, "status")));
  }

  protected AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent parseAdministrableProductDefinitionRouteOfAdministrationComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent res = new AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent();
    parseAdministrableProductDefinitionRouteOfAdministrationComponentProperties(json, res);
    return res;
  }

  protected void parseAdministrableProductDefinitionRouteOfAdministrationComponentProperties(JsonObject json, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("firstDose"))
      res.setFirstDose(parseQuantity(getJObject(json, "firstDose")));
    if (json.has("maxSingleDose"))
      res.setMaxSingleDose(parseQuantity(getJObject(json, "maxSingleDose")));
    if (json.has("maxDosePerDay"))
      res.setMaxDosePerDay(parseQuantity(getJObject(json, "maxDosePerDay")));
    if (json.has("maxDosePerTreatmentPeriod"))
      res.setMaxDosePerTreatmentPeriod(parseRatio(getJObject(json, "maxDosePerTreatmentPeriod")));
    if (json.has("maxTreatmentPeriod"))
      res.setMaxTreatmentPeriod(parseDuration(getJObject(json, "maxTreatmentPeriod")));
    if (json.has("targetSpecies")) {
      JsonArray array = getJArray(json, "targetSpecies");
      for (int i = 0; i < array.size(); i++) {
        res.getTargetSpecies().add(parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent res = new AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent();
    parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponentProperties(json, res);
    return res;
  }

  protected void parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponentProperties(JsonObject json, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("withdrawalPeriod")) {
      JsonArray array = getJArray(json, "withdrawalPeriod");
      for (int i = 0; i < array.size(); i++) {
        res.getWithdrawalPeriod().add(parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent res = new AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent();
    parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponentProperties(json, res);
    return res;
  }

  protected void parseAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponentProperties(JsonObject json, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("tissue"))
      res.setTissue(parseCodeableConcept(getJObject(json, "tissue")));
    if (json.has("value"))
      res.setValue(parseQuantity(getJObject(json, "value")));
    if (json.has("supportingInformation"))
      res.setSupportingInformationElement(parseString(json.get("supportingInformation").getAsString()));
    if (json.has("_supportingInformation"))
      parseElementProperties(getJObject(json, "_supportingInformation"), res.getSupportingInformationElement());
  }

  protected AdverseEvent parseAdverseEvent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent res = new AdverseEvent();
    parseAdverseEventProperties(json, res);
    return res;
  }

  protected void parseAdverseEventProperties(JsonObject json, AdverseEvent res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), AdverseEvent.AdverseEventStatus.NULL, new AdverseEvent.AdverseEventStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("actuality"))
      res.setActualityElement(parseEnumeration(json.get("actuality").getAsString(), AdverseEvent.AdverseEventActuality.NULL, new AdverseEvent.AdverseEventActualityEnumFactory()));
    if (json.has("_actuality"))
      parseElementProperties(getJObject(json, "_actuality"), res.getActualityElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    DataType occurrence = parseType("occurrence", json);
    if (occurrence != null)
      res.setOccurrence(occurrence);
    if (json.has("detected"))
      res.setDetectedElement(parseDateTime(json.get("detected").getAsString()));
    if (json.has("_detected"))
      parseElementProperties(getJObject(json, "_detected"), res.getDetectedElement());
    if (json.has("recordedDate"))
      res.setRecordedDateElement(parseDateTime(json.get("recordedDate").getAsString()));
    if (json.has("_recordedDate"))
      parseElementProperties(getJObject(json, "_recordedDate"), res.getRecordedDateElement());
    if (json.has("resultingCondition")) {
      JsonArray array = getJArray(json, "resultingCondition");
      for (int i = 0; i < array.size(); i++) {
        res.getResultingCondition().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("location"))
      res.setLocation(parseReference(getJObject(json, "location")));
    if (json.has("seriousness"))
      res.setSeriousness(parseCodeableConcept(getJObject(json, "seriousness")));
    if (json.has("outcome")) {
      JsonArray array = getJArray(json, "outcome");
      for (int i = 0; i < array.size(); i++) {
        res.getOutcome().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("recorder"))
      res.setRecorder(parseReference(getJObject(json, "recorder")));
    if (json.has("participant")) {
      JsonArray array = getJArray(json, "participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseAdverseEventParticipantComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("study")) {
      JsonArray array = getJArray(json, "study");
      for (int i = 0; i < array.size(); i++) {
        res.getStudy().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("expectedInResearchStudy"))
      res.setExpectedInResearchStudyElement(parseBoolean(json.get("expectedInResearchStudy").getAsBoolean()));
    if (json.has("_expectedInResearchStudy"))
      parseElementProperties(getJObject(json, "_expectedInResearchStudy"), res.getExpectedInResearchStudyElement());
    if (json.has("suspectEntity")) {
      JsonArray array = getJArray(json, "suspectEntity");
      for (int i = 0; i < array.size(); i++) {
        res.getSuspectEntity().add(parseAdverseEventSuspectEntityComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("contributingFactor")) {
      JsonArray array = getJArray(json, "contributingFactor");
      for (int i = 0; i < array.size(); i++) {
        res.getContributingFactor().add(parseAdverseEventContributingFactorComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("preventiveAction")) {
      JsonArray array = getJArray(json, "preventiveAction");
      for (int i = 0; i < array.size(); i++) {
        res.getPreventiveAction().add(parseAdverseEventPreventiveActionComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("mitigatingAction")) {
      JsonArray array = getJArray(json, "mitigatingAction");
      for (int i = 0; i < array.size(); i++) {
        res.getMitigatingAction().add(parseAdverseEventMitigatingActionComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInfo")) {
      JsonArray array = getJArray(json, "supportingInfo");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInfo().add(parseAdverseEventSupportingInfoComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AdverseEvent.AdverseEventParticipantComponent parseAdverseEventParticipantComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventParticipantComponent res = new AdverseEvent.AdverseEventParticipantComponent();
    parseAdverseEventParticipantComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventParticipantComponentProperties(JsonObject json, AdverseEvent.AdverseEventParticipantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("function"))
      res.setFunction(parseCodeableConcept(getJObject(json, "function")));
    if (json.has("actor"))
      res.setActor(parseReference(getJObject(json, "actor")));
  }

  protected AdverseEvent.AdverseEventSuspectEntityComponent parseAdverseEventSuspectEntityComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventSuspectEntityComponent res = new AdverseEvent.AdverseEventSuspectEntityComponent();
    parseAdverseEventSuspectEntityComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventSuspectEntityComponentProperties(JsonObject json, AdverseEvent.AdverseEventSuspectEntityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType instance = parseType("instance", json);
    if (instance != null)
      res.setInstance(instance);
    if (json.has("causality"))
      res.setCausality(parseAdverseEventSuspectEntityCausalityComponent(getJObject(json, "causality")));
  }

  protected AdverseEvent.AdverseEventSuspectEntityCausalityComponent parseAdverseEventSuspectEntityCausalityComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventSuspectEntityCausalityComponent res = new AdverseEvent.AdverseEventSuspectEntityCausalityComponent();
    parseAdverseEventSuspectEntityCausalityComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventSuspectEntityCausalityComponentProperties(JsonObject json, AdverseEvent.AdverseEventSuspectEntityCausalityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("assessmentMethod"))
      res.setAssessmentMethod(parseCodeableConcept(getJObject(json, "assessmentMethod")));
    if (json.has("entityRelatedness"))
      res.setEntityRelatedness(parseCodeableConcept(getJObject(json, "entityRelatedness")));
    if (json.has("author"))
      res.setAuthor(parseReference(getJObject(json, "author")));
  }

  protected AdverseEvent.AdverseEventContributingFactorComponent parseAdverseEventContributingFactorComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventContributingFactorComponent res = new AdverseEvent.AdverseEventContributingFactorComponent();
    parseAdverseEventContributingFactorComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventContributingFactorComponentProperties(JsonObject json, AdverseEvent.AdverseEventContributingFactorComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType item = parseType("item", json);
    if (item != null)
      res.setItem(item);
  }

  protected AdverseEvent.AdverseEventPreventiveActionComponent parseAdverseEventPreventiveActionComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventPreventiveActionComponent res = new AdverseEvent.AdverseEventPreventiveActionComponent();
    parseAdverseEventPreventiveActionComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventPreventiveActionComponentProperties(JsonObject json, AdverseEvent.AdverseEventPreventiveActionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType item = parseType("item", json);
    if (item != null)
      res.setItem(item);
  }

  protected AdverseEvent.AdverseEventMitigatingActionComponent parseAdverseEventMitigatingActionComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventMitigatingActionComponent res = new AdverseEvent.AdverseEventMitigatingActionComponent();
    parseAdverseEventMitigatingActionComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventMitigatingActionComponentProperties(JsonObject json, AdverseEvent.AdverseEventMitigatingActionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType item = parseType("item", json);
    if (item != null)
      res.setItem(item);
  }

  protected AdverseEvent.AdverseEventSupportingInfoComponent parseAdverseEventSupportingInfoComponent(JsonObject json) throws IOException, FHIRFormatError {
    AdverseEvent.AdverseEventSupportingInfoComponent res = new AdverseEvent.AdverseEventSupportingInfoComponent();
    parseAdverseEventSupportingInfoComponentProperties(json, res);
    return res;
  }

  protected void parseAdverseEventSupportingInfoComponentProperties(JsonObject json, AdverseEvent.AdverseEventSupportingInfoComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType item = parseType("item", json);
    if (item != null)
      res.setItem(item);
  }

  protected AllergyIntolerance parseAllergyIntolerance(JsonObject json) throws IOException, FHIRFormatError {
    AllergyIntolerance res = new AllergyIntolerance();
    parseAllergyIntoleranceProperties(json, res);
    return res;
  }

  protected void parseAllergyIntoleranceProperties(JsonObject json, AllergyIntolerance res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("clinicalStatus"))
      res.setClinicalStatus(parseCodeableConcept(getJObject(json, "clinicalStatus")));
    if (json.has("verificationStatus"))
      res.setVerificationStatus(parseCodeableConcept(getJObject(json, "verificationStatus")));
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), AllergyIntolerance.AllergyIntoleranceType.NULL, new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getCategory().add(new Enumeration<AllergyIntolerance.AllergyIntoleranceCategory>(new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory(), AllergyIntolerance.AllergyIntoleranceCategory.NULL));
        } else {;
          res.getCategory().add(parseEnumeration(array.get(i).getAsString(), AllergyIntolerance.AllergyIntoleranceCategory.NULL, new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory()));
        }
      }
    };
    if (json.has("_category")) {
      JsonArray array = getJArray(json, "_category");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getCategory().size())
          res.getCategory().add(parseEnumeration(null, AllergyIntolerance.AllergyIntoleranceCategory.NULL, new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory()));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getCategory().get(i));
      }
    };
    if (json.has("criticality"))
      res.setCriticalityElement(parseEnumeration(json.get("criticality").getAsString(), AllergyIntolerance.AllergyIntoleranceCriticality.NULL, new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory()));
    if (json.has("_criticality"))
      parseElementProperties(getJObject(json, "_criticality"), res.getCriticalityElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("patient"))
      res.setPatient(parseReference(getJObject(json, "patient")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    DataType onset = parseType("onset", json);
    if (onset != null)
      res.setOnset(onset);
    if (json.has("recordedDate"))
      res.setRecordedDateElement(parseDateTime(json.get("recordedDate").getAsString()));
    if (json.has("_recordedDate"))
      parseElementProperties(getJObject(json, "_recordedDate"), res.getRecordedDateElement());
    if (json.has("participant")) {
      JsonArray array = getJArray(json, "participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseAllergyIntoleranceParticipantComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("lastOccurrence"))
      res.setLastOccurrenceElement(parseDateTime(json.get("lastOccurrence").getAsString()));
    if (json.has("_lastOccurrence"))
      parseElementProperties(getJObject(json, "_lastOccurrence"), res.getLastOccurrenceElement());
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reaction")) {
      JsonArray array = getJArray(json, "reaction");
      for (int i = 0; i < array.size(); i++) {
        res.getReaction().add(parseAllergyIntoleranceReactionComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AllergyIntolerance.AllergyIntoleranceParticipantComponent parseAllergyIntoleranceParticipantComponent(JsonObject json) throws IOException, FHIRFormatError {
    AllergyIntolerance.AllergyIntoleranceParticipantComponent res = new AllergyIntolerance.AllergyIntoleranceParticipantComponent();
    parseAllergyIntoleranceParticipantComponentProperties(json, res);
    return res;
  }

  protected void parseAllergyIntoleranceParticipantComponentProperties(JsonObject json, AllergyIntolerance.AllergyIntoleranceParticipantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("function"))
      res.setFunction(parseCodeableConcept(getJObject(json, "function")));
    if (json.has("actor"))
      res.setActor(parseReference(getJObject(json, "actor")));
  }

  protected AllergyIntolerance.AllergyIntoleranceReactionComponent parseAllergyIntoleranceReactionComponent(JsonObject json) throws IOException, FHIRFormatError {
    AllergyIntolerance.AllergyIntoleranceReactionComponent res = new AllergyIntolerance.AllergyIntoleranceReactionComponent();
    parseAllergyIntoleranceReactionComponentProperties(json, res);
    return res;
  }

  protected void parseAllergyIntoleranceReactionComponentProperties(JsonObject json, AllergyIntolerance.AllergyIntoleranceReactionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("substance"))
      res.setSubstance(parseCodeableConcept(getJObject(json, "substance")));
    if (json.has("manifestation")) {
      JsonArray array = getJArray(json, "manifestation");
      for (int i = 0; i < array.size(); i++) {
        res.getManifestation().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("onset"))
      res.setOnsetElement(parseDateTime(json.get("onset").getAsString()));
    if (json.has("_onset"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_severity"), res.getSeverityElement());
    if (json.has("exposureRoute"))
      res.setExposureRoute(parseCodeableConcept(getJObject(json, "exposureRoute")));
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Appointment parseAppointment(JsonObject json) throws IOException, FHIRFormatError {
    Appointment res = new Appointment();
    parseAppointmentProperties(json, res);
    return res;
  }

  protected void parseAppointmentProperties(JsonObject json, Appointment res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("cancellationReason"))
      res.setCancellationReason(parseCodeableConcept(getJObject(json, "cancellationReason")));
    if (json.has("class")) {
      JsonArray array = getJArray(json, "class");
      for (int i = 0; i < array.size(); i++) {
        res.getClass_().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("serviceCategory")) {
      JsonArray array = getJArray(json, "serviceCategory");
      for (int i = 0; i < array.size(); i++) {
        res.getServiceCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("serviceType")) {
      JsonArray array = getJArray(json, "serviceType");
      for (int i = 0; i < array.size(); i++) {
        res.getServiceType().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("specialty")) {
      JsonArray array = getJArray(json, "specialty");
      for (int i = 0; i < array.size(); i++) {
        res.getSpecialty().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("appointmentType"))
      res.setAppointmentType(parseCodeableConcept(getJObject(json, "appointmentType")));
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(getJObject(json, "priority")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("replaces")) {
      JsonArray array = getJArray(json, "replaces");
      for (int i = 0; i < array.size(); i++) {
        res.getReplaces().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("virtualService")) {
      JsonArray array = getJArray(json, "virtualService");
      for (int i = 0; i < array.size(); i++) {
        res.getVirtualService().add(parseVirtualServiceDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInformation")) {
      JsonArray array = getJArray(json, "supportingInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("previousAppointment"))
      res.setPreviousAppointment(parseReference(getJObject(json, "previousAppointment")));
    if (json.has("originatingAppointment"))
      res.setOriginatingAppointment(parseReference(getJObject(json, "originatingAppointment")));
    if (json.has("start"))
      res.setStartElement(parseInstant(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(getJObject(json, "_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(getJObject(json, "_end"), res.getEndElement());
    if (json.has("minutesDuration"))
      res.setMinutesDurationElement(parsePositiveInt(json.get("minutesDuration").getAsString()));
    if (json.has("_minutesDuration"))
      parseElementProperties(getJObject(json, "_minutesDuration"), res.getMinutesDurationElement());
    if (json.has("slot")) {
      JsonArray array = getJArray(json, "slot");
      for (int i = 0; i < array.size(); i++) {
        res.getSlot().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("account")) {
      JsonArray array = getJArray(json, "account");
      for (int i = 0; i < array.size(); i++) {
        res.getAccount().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(getJObject(json, "_created"), res.getCreatedElement());
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patientInstruction")) {
      JsonArray array = getJArray(json, "patientInstruction");
      for (int i = 0; i < array.size(); i++) {
        res.getPatientInstruction().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("basedOn")) {
      JsonArray array = getJArray(json, "basedOn");
      for (int i = 0; i < array.size(); i++) {
        res.getBasedOn().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("participant")) {
      JsonArray array = getJArray(json, "participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseAppointmentParticipantComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("requestedPeriod")) {
      JsonArray array = getJArray(json, "requestedPeriod");
      for (int i = 0; i < array.size(); i++) {
        res.getRequestedPeriod().add(parsePeriod(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("recurrenceId"))
      res.setRecurrenceIdElement(parsePositiveInt(json.get("recurrenceId").getAsString()));
    if (json.has("_recurrenceId"))
      parseElementProperties(getJObject(json, "_recurrenceId"), res.getRecurrenceIdElement());
    if (json.has("occurrenceChanged"))
      res.setOccurrenceChangedElement(parseBoolean(json.get("occurrenceChanged").getAsBoolean()));
    if (json.has("_occurrenceChanged"))
      parseElementProperties(getJObject(json, "_occurrenceChanged"), res.getOccurrenceChangedElement());
    if (json.has("recurrenceTemplate")) {
      JsonArray array = getJArray(json, "recurrenceTemplate");
      for (int i = 0; i < array.size(); i++) {
        res.getRecurrenceTemplate().add(parseAppointmentRecurrenceTemplateComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Appointment.AppointmentParticipantComponent parseAppointmentParticipantComponent(JsonObject json) throws IOException, FHIRFormatError {
    Appointment.AppointmentParticipantComponent res = new Appointment.AppointmentParticipantComponent();
    parseAppointmentParticipantComponentProperties(json, res);
    return res;
  }

  protected void parseAppointmentParticipantComponentProperties(JsonObject json, Appointment.AppointmentParticipantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
    if (json.has("actor"))
      res.setActor(parseReference(getJObject(json, "actor")));
    if (json.has("required"))
      res.setRequiredElement(parseBoolean(json.get("required").getAsBoolean()));
    if (json.has("_required"))
      parseElementProperties(getJObject(json, "_required"), res.getRequiredElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.ParticipationStatus.NULL, new Enumerations.ParticipationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
  }

  protected Appointment.AppointmentRecurrenceTemplateComponent parseAppointmentRecurrenceTemplateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Appointment.AppointmentRecurrenceTemplateComponent res = new Appointment.AppointmentRecurrenceTemplateComponent();
    parseAppointmentRecurrenceTemplateComponentProperties(json, res);
    return res;
  }

  protected void parseAppointmentRecurrenceTemplateComponentProperties(JsonObject json, Appointment.AppointmentRecurrenceTemplateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("timezone"))
      res.setTimezone(parseCodeableConcept(getJObject(json, "timezone")));
    if (json.has("recurrenceType"))
      res.setRecurrenceType(parseCodeableConcept(getJObject(json, "recurrenceType")));
    if (json.has("lastOccurrenceDate"))
      res.setLastOccurrenceDateElement(parseDate(json.get("lastOccurrenceDate").getAsString()));
    if (json.has("_lastOccurrenceDate"))
      parseElementProperties(getJObject(json, "_lastOccurrenceDate"), res.getLastOccurrenceDateElement());
    if (json.has("occurrenceCount"))
      res.setOccurrenceCountElement(parsePositiveInt(json.get("occurrenceCount").getAsString()));
    if (json.has("_occurrenceCount"))
      parseElementProperties(getJObject(json, "_occurrenceCount"), res.getOccurrenceCountElement());
    if (json.has("occurrenceDate")) {
      JsonArray array = getJArray(json, "occurrenceDate");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getOccurrenceDate().add(new DateType());
        } else {;
          res.getOccurrenceDate().add(parseDate(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_occurrenceDate")) {
      JsonArray array = getJArray(json, "_occurrenceDate");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getOccurrenceDate().size())
          res.getOccurrenceDate().add(parseDate(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getOccurrenceDate().get(i));
      }
    };
    if (json.has("weeklyTemplate"))
      res.setWeeklyTemplate(parseAppointmentRecurrenceTemplateWeeklyTemplateComponent(getJObject(json, "weeklyTemplate")));
    if (json.has("monthlyTemplate"))
      res.setMonthlyTemplate(parseAppointmentRecurrenceTemplateMonthlyTemplateComponent(getJObject(json, "monthlyTemplate")));
    if (json.has("yearlyTemplate"))
      res.setYearlyTemplate(parseAppointmentRecurrenceTemplateYearlyTemplateComponent(getJObject(json, "yearlyTemplate")));
    if (json.has("excludingDate")) {
      JsonArray array = getJArray(json, "excludingDate");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getExcludingDate().add(new DateType());
        } else {;
          res.getExcludingDate().add(parseDate(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_excludingDate")) {
      JsonArray array = getJArray(json, "_excludingDate");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getExcludingDate().size())
          res.getExcludingDate().add(parseDate(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getExcludingDate().get(i));
      }
    };
    if (json.has("excludingRecurrenceId")) {
      JsonArray array = getJArray(json, "excludingRecurrenceId");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getExcludingRecurrenceId().add(new PositiveIntType());
        } else {;
          res.getExcludingRecurrenceId().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_excludingRecurrenceId")) {
      JsonArray array = getJArray(json, "_excludingRecurrenceId");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getExcludingRecurrenceId().size())
          res.getExcludingRecurrenceId().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getExcludingRecurrenceId().get(i));
      }
    };
  }

  protected Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent parseAppointmentRecurrenceTemplateWeeklyTemplateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent res = new Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent();
    parseAppointmentRecurrenceTemplateWeeklyTemplateComponentProperties(json, res);
    return res;
  }

  protected void parseAppointmentRecurrenceTemplateWeeklyTemplateComponentProperties(JsonObject json, Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("monday"))
      res.setMondayElement(parseBoolean(json.get("monday").getAsBoolean()));
    if (json.has("_monday"))
      parseElementProperties(getJObject(json, "_monday"), res.getMondayElement());
    if (json.has("tuesday"))
      res.setTuesdayElement(parseBoolean(json.get("tuesday").getAsBoolean()));
    if (json.has("_tuesday"))
      parseElementProperties(getJObject(json, "_tuesday"), res.getTuesdayElement());
    if (json.has("wednesday"))
      res.setWednesdayElement(parseBoolean(json.get("wednesday").getAsBoolean()));
    if (json.has("_wednesday"))
      parseElementProperties(getJObject(json, "_wednesday"), res.getWednesdayElement());
    if (json.has("thursday"))
      res.setThursdayElement(parseBoolean(json.get("thursday").getAsBoolean()));
    if (json.has("_thursday"))
      parseElementProperties(getJObject(json, "_thursday"), res.getThursdayElement());
    if (json.has("friday"))
      res.setFridayElement(parseBoolean(json.get("friday").getAsBoolean()));
    if (json.has("_friday"))
      parseElementProperties(getJObject(json, "_friday"), res.getFridayElement());
    if (json.has("saturday"))
      res.setSaturdayElement(parseBoolean(json.get("saturday").getAsBoolean()));
    if (json.has("_saturday"))
      parseElementProperties(getJObject(json, "_saturday"), res.getSaturdayElement());
    if (json.has("sunday"))
      res.setSundayElement(parseBoolean(json.get("sunday").getAsBoolean()));
    if (json.has("_sunday"))
      parseElementProperties(getJObject(json, "_sunday"), res.getSundayElement());
    if (json.has("weekInterval"))
      res.setWeekIntervalElement(parsePositiveInt(json.get("weekInterval").getAsString()));
    if (json.has("_weekInterval"))
      parseElementProperties(getJObject(json, "_weekInterval"), res.getWeekIntervalElement());
  }

  protected Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent parseAppointmentRecurrenceTemplateMonthlyTemplateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent res = new Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent();
    parseAppointmentRecurrenceTemplateMonthlyTemplateComponentProperties(json, res);
    return res;
  }

  protected void parseAppointmentRecurrenceTemplateMonthlyTemplateComponentProperties(JsonObject json, Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("dayOfMonth"))
      res.setDayOfMonthElement(parsePositiveInt(json.get("dayOfMonth").getAsString()));
    if (json.has("_dayOfMonth"))
      parseElementProperties(getJObject(json, "_dayOfMonth"), res.getDayOfMonthElement());
    if (json.has("nthWeekOfMonth"))
      res.setNthWeekOfMonth(parseCoding(getJObject(json, "nthWeekOfMonth")));
    if (json.has("dayOfWeek"))
      res.setDayOfWeek(parseCoding(getJObject(json, "dayOfWeek")));
    if (json.has("monthInterval"))
      res.setMonthIntervalElement(parsePositiveInt(json.get("monthInterval").getAsString()));
    if (json.has("_monthInterval"))
      parseElementProperties(getJObject(json, "_monthInterval"), res.getMonthIntervalElement());
  }

  protected Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent parseAppointmentRecurrenceTemplateYearlyTemplateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent res = new Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent();
    parseAppointmentRecurrenceTemplateYearlyTemplateComponentProperties(json, res);
    return res;
  }

  protected void parseAppointmentRecurrenceTemplateYearlyTemplateComponentProperties(JsonObject json, Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("yearInterval"))
      res.setYearIntervalElement(parsePositiveInt(json.get("yearInterval").getAsString()));
    if (json.has("_yearInterval"))
      parseElementProperties(getJObject(json, "_yearInterval"), res.getYearIntervalElement());
  }

  protected AppointmentResponse parseAppointmentResponse(JsonObject json) throws IOException, FHIRFormatError {
    AppointmentResponse res = new AppointmentResponse();
    parseAppointmentResponseProperties(json, res);
    return res;
  }

  protected void parseAppointmentResponseProperties(JsonObject json, AppointmentResponse res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("appointment"))
      res.setAppointment(parseReference(getJObject(json, "appointment")));
    if (json.has("proposedNewTime"))
      res.setProposedNewTimeElement(parseBoolean(json.get("proposedNewTime").getAsBoolean()));
    if (json.has("_proposedNewTime"))
      parseElementProperties(getJObject(json, "_proposedNewTime"), res.getProposedNewTimeElement());
    if (json.has("start"))
      res.setStartElement(parseInstant(json.get("start").getAsString()));
    if (json.has("_start"))
      parseElementProperties(getJObject(json, "_start"), res.getStartElement());
    if (json.has("end"))
      res.setEndElement(parseInstant(json.get("end").getAsString()));
    if (json.has("_end"))
      parseElementProperties(getJObject(json, "_end"), res.getEndElement());
    if (json.has("participantType")) {
      JsonArray array = getJArray(json, "participantType");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipantType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("actor"))
      res.setActor(parseReference(getJObject(json, "actor")));
    if (json.has("participantStatus"))
      res.setParticipantStatusElement(parseEnumeration(json.get("participantStatus").getAsString(), Enumerations.ParticipationStatus.NULL, new Enumerations.ParticipationStatusEnumFactory()));
    if (json.has("_participantStatus"))
      parseElementProperties(getJObject(json, "_participantStatus"), res.getParticipantStatusElement());
    if (json.has("comment"))
      res.setCommentElement(parseString(json.get("comment").getAsString()));
    if (json.has("_comment"))
      parseElementProperties(getJObject(json, "_comment"), res.getCommentElement());
    if (json.has("recurring"))
      res.setRecurringElement(parseBoolean(json.get("recurring").getAsBoolean()));
    if (json.has("_recurring"))
      parseElementProperties(getJObject(json, "_recurring"), res.getRecurringElement());
    if (json.has("occurrenceDate"))
      res.setOccurrenceDateElement(parseDate(json.get("occurrenceDate").getAsString()));
    if (json.has("_occurrenceDate"))
      parseElementProperties(getJObject(json, "_occurrenceDate"), res.getOccurrenceDateElement());
    if (json.has("recurrenceId"))
      res.setRecurrenceIdElement(parsePositiveInt(json.get("recurrenceId").getAsString()));
    if (json.has("_recurrenceId"))
      parseElementProperties(getJObject(json, "_recurrenceId"), res.getRecurrenceIdElement());
  }

  protected ArtifactAssessment parseArtifactAssessment(JsonObject json) throws IOException, FHIRFormatError {
    ArtifactAssessment res = new ArtifactAssessment();
    parseArtifactAssessmentProperties(json, res);
    return res;
  }

  protected void parseArtifactAssessmentProperties(JsonObject json, ArtifactAssessment res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    DataType citeAs = parseType("citeAs", json);
    if (citeAs != null)
      res.setCiteAs(citeAs);
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("approvalDate"))
      res.setApprovalDateElement(parseDate(json.get("approvalDate").getAsString()));
    if (json.has("_approvalDate"))
      parseElementProperties(getJObject(json, "_approvalDate"), res.getApprovalDateElement());
    if (json.has("lastReviewDate"))
      res.setLastReviewDateElement(parseDate(json.get("lastReviewDate").getAsString()));
    if (json.has("_lastReviewDate"))
      parseElementProperties(getJObject(json, "_lastReviewDate"), res.getLastReviewDateElement());
    DataType artifact = parseType("artifact", json);
    if (artifact != null)
      res.setArtifact(artifact);
    if (json.has("content")) {
      JsonArray array = getJArray(json, "content");
      for (int i = 0; i < array.size(); i++) {
        res.getContent().add(parseArtifactAssessmentContentComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("workflowStatus"))
      res.setWorkflowStatusElement(parseEnumeration(json.get("workflowStatus").getAsString(), ArtifactAssessment.ArtifactAssessmentWorkflowStatus.NULL, new ArtifactAssessment.ArtifactAssessmentWorkflowStatusEnumFactory()));
    if (json.has("_workflowStatus"))
      parseElementProperties(getJObject(json, "_workflowStatus"), res.getWorkflowStatusElement());
    if (json.has("disposition"))
      res.setDispositionElement(parseEnumeration(json.get("disposition").getAsString(), ArtifactAssessment.ArtifactAssessmentDisposition.NULL, new ArtifactAssessment.ArtifactAssessmentDispositionEnumFactory()));
    if (json.has("_disposition"))
      parseElementProperties(getJObject(json, "_disposition"), res.getDispositionElement());
  }

  protected ArtifactAssessment.ArtifactAssessmentContentComponent parseArtifactAssessmentContentComponent(JsonObject json) throws IOException, FHIRFormatError {
    ArtifactAssessment.ArtifactAssessmentContentComponent res = new ArtifactAssessment.ArtifactAssessmentContentComponent();
    parseArtifactAssessmentContentComponentProperties(json, res);
    return res;
  }

  protected void parseArtifactAssessmentContentComponentProperties(JsonObject json, ArtifactAssessment.ArtifactAssessmentContentComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("informationType"))
      res.setInformationTypeElement(parseEnumeration(json.get("informationType").getAsString(), ArtifactAssessment.ArtifactAssessmentInformationType.NULL, new ArtifactAssessment.ArtifactAssessmentInformationTypeEnumFactory()));
    if (json.has("_informationType"))
      parseElementProperties(getJObject(json, "_informationType"), res.getInformationTypeElement());
    if (json.has("summary"))
      res.setSummaryElement(parseMarkdown(json.get("summary").getAsString()));
    if (json.has("_summary"))
      parseElementProperties(getJObject(json, "_summary"), res.getSummaryElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("author"))
      res.setAuthor(parseReference(getJObject(json, "author")));
    if (json.has("path")) {
      JsonArray array = getJArray(json, "path");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPath().add(new UriType());
        } else {;
          res.getPath().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_path")) {
      JsonArray array = getJArray(json, "_path");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPath().size())
          res.getPath().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPath().get(i));
      }
    };
    if (json.has("relatedArtifact")) {
      JsonArray array = getJArray(json, "relatedArtifact");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedArtifact().add(parseRelatedArtifact(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("freeToShare"))
      res.setFreeToShareElement(parseBoolean(json.get("freeToShare").getAsBoolean()));
    if (json.has("_freeToShare"))
      parseElementProperties(getJObject(json, "_freeToShare"), res.getFreeToShareElement());
    if (json.has("component")) {
      JsonArray array = getJArray(json, "component");
      for (int i = 0; i < array.size(); i++) {
        res.getComponent().add(parseArtifactAssessmentContentComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent parseAuditEvent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent res = new AuditEvent();
    parseAuditEventProperties(json, res);
    return res;
  }

  protected void parseAuditEventProperties(JsonObject json, AuditEvent res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("action"))
      res.setActionElement(parseEnumeration(json.get("action").getAsString(), AuditEvent.AuditEventAction.NULL, new AuditEvent.AuditEventActionEnumFactory()));
    if (json.has("_action"))
      parseElementProperties(getJObject(json, "_action"), res.getActionElement());
    if (json.has("severity"))
      res.setSeverityElement(parseEnumeration(json.get("severity").getAsString(), AuditEvent.AuditEventSeverity.NULL, new AuditEvent.AuditEventSeverityEnumFactory()));
    if (json.has("_severity"))
      parseElementProperties(getJObject(json, "_severity"), res.getSeverityElement());
    DataType occurred = parseType("occurred", json);
    if (occurred != null)
      res.setOccurred(occurred);
    if (json.has("recorded"))
      res.setRecordedElement(parseInstant(json.get("recorded").getAsString()));
    if (json.has("_recorded"))
      parseElementProperties(getJObject(json, "_recorded"), res.getRecordedElement());
    if (json.has("outcome"))
      res.setOutcome(parseAuditEventOutcomeComponent(getJObject(json, "outcome")));
    if (json.has("authorization")) {
      JsonArray array = getJArray(json, "authorization");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthorization().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("basedOn")) {
      JsonArray array = getJArray(json, "basedOn");
      for (int i = 0; i < array.size(); i++) {
        res.getBasedOn().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patient"))
      res.setPatient(parseReference(getJObject(json, "patient")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    if (json.has("agent")) {
      JsonArray array = getJArray(json, "agent");
      for (int i = 0; i < array.size(); i++) {
        res.getAgent().add(parseAuditEventAgentComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("source"))
      res.setSource(parseAuditEventSourceComponent(getJObject(json, "source")));
    if (json.has("entity")) {
      JsonArray array = getJArray(json, "entity");
      for (int i = 0; i < array.size(); i++) {
        res.getEntity().add(parseAuditEventEntityComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent.AuditEventOutcomeComponent parseAuditEventOutcomeComponent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventOutcomeComponent res = new AuditEvent.AuditEventOutcomeComponent();
    parseAuditEventOutcomeComponentProperties(json, res);
    return res;
  }

  protected void parseAuditEventOutcomeComponentProperties(JsonObject json, AuditEvent.AuditEventOutcomeComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCode(parseCoding(getJObject(json, "code")));
    if (json.has("detail")) {
      JsonArray array = getJArray(json, "detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent.AuditEventAgentComponent parseAuditEventAgentComponent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventAgentComponent res = new AuditEvent.AuditEventAgentComponent();
    parseAuditEventAgentComponentProperties(json, res);
    return res;
  }

  protected void parseAuditEventAgentComponentProperties(JsonObject json, AuditEvent.AuditEventAgentComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("role")) {
      JsonArray array = getJArray(json, "role");
      for (int i = 0; i < array.size(); i++) {
        res.getRole().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("who"))
      res.setWho(parseReference(getJObject(json, "who")));
    if (json.has("requestor"))
      res.setRequestorElement(parseBoolean(json.get("requestor").getAsBoolean()));
    if (json.has("_requestor"))
      parseElementProperties(getJObject(json, "_requestor"), res.getRequestorElement());
    if (json.has("location"))
      res.setLocation(parseReference(getJObject(json, "location")));
    if (json.has("policy")) {
      JsonArray array = getJArray(json, "policy");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPolicy().add(new UriType());
        } else {;
          res.getPolicy().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_policy")) {
      JsonArray array = getJArray(json, "_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));
      }
    };
    DataType network = parseType("network", json);
    if (network != null)
      res.setNetwork(network);
    if (json.has("authorization")) {
      JsonArray array = getJArray(json, "authorization");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthorization().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent.AuditEventSourceComponent parseAuditEventSourceComponent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventSourceComponent res = new AuditEvent.AuditEventSourceComponent();
    parseAuditEventSourceComponentProperties(json, res);
    return res;
  }

  protected void parseAuditEventSourceComponentProperties(JsonObject json, AuditEvent.AuditEventSourceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("site"))
      res.setSite(parseReference(getJObject(json, "site")));
    if (json.has("observer"))
      res.setObserver(parseReference(getJObject(json, "observer")));
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent.AuditEventEntityComponent parseAuditEventEntityComponent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventEntityComponent res = new AuditEvent.AuditEventEntityComponent();
    parseAuditEventEntityComponentProperties(json, res);
    return res;
  }

  protected void parseAuditEventEntityComponentProperties(JsonObject json, AuditEvent.AuditEventEntityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("what"))
      res.setWhat(parseReference(getJObject(json, "what")));
    if (json.has("role"))
      res.setRole(parseCodeableConcept(getJObject(json, "role")));
    if (json.has("securityLabel")) {
      JsonArray array = getJArray(json, "securityLabel");
      for (int i = 0; i < array.size(); i++) {
        res.getSecurityLabel().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("query"))
      res.setQueryElement(parseBase64Binary(json.get("query").getAsString()));
    if (json.has("_query"))
      parseElementProperties(getJObject(json, "_query"), res.getQueryElement());
    if (json.has("detail")) {
      JsonArray array = getJArray(json, "detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseAuditEventEntityDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("agent")) {
      JsonArray array = getJArray(json, "agent");
      for (int i = 0; i < array.size(); i++) {
        res.getAgent().add(parseAuditEventAgentComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected AuditEvent.AuditEventEntityDetailComponent parseAuditEventEntityDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    AuditEvent.AuditEventEntityDetailComponent res = new AuditEvent.AuditEventEntityDetailComponent();
    parseAuditEventEntityDetailComponentProperties(json, res);
    return res;
  }

  protected void parseAuditEventEntityDetailComponentProperties(JsonObject json, AuditEvent.AuditEventEntityDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected Basic parseBasic(JsonObject json) throws IOException, FHIRFormatError {
    Basic res = new Basic();
    parseBasicProperties(json, res);
    return res;
  }

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

  protected Binary parseBinary(JsonObject json) throws IOException, FHIRFormatError {
    Binary res = new Binary();
    parseBinaryProperties(json, res);
    return res;
  }

  protected void parseBinaryProperties(JsonObject json, Binary res) throws IOException, FHIRFormatError {
    parseResourceProperties(json, res);
    if (json.has("contentType"))
      res.setContentTypeElement(parseCode(json.get("contentType").getAsString()));
    if (json.has("_contentType"))
      parseElementProperties(getJObject(json, "_contentType"), res.getContentTypeElement());
    if (json.has("securityContext"))
      res.setSecurityContext(parseReference(getJObject(json, "securityContext")));
    if (json.has("data"))
      res.setDataElement(parseBase64Binary(json.get("data").getAsString()));
    if (json.has("_data"))
      parseElementProperties(getJObject(json, "_data"), res.getDataElement());
  }

  protected BiologicallyDerivedProduct parseBiologicallyDerivedProduct(JsonObject json) throws IOException, FHIRFormatError {
    BiologicallyDerivedProduct res = new BiologicallyDerivedProduct();
    parseBiologicallyDerivedProductProperties(json, res);
    return res;
  }

  protected void parseBiologicallyDerivedProductProperties(JsonObject json, BiologicallyDerivedProduct res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("productCategory"))
      res.setProductCategory(parseCoding(getJObject(json, "productCategory")));
    if (json.has("productCode"))
      res.setProductCode(parseCodeableConcept(getJObject(json, "productCode")));
    if (json.has("parent")) {
      JsonArray array = getJArray(json, "parent");
      for (int i = 0; i < array.size(); i++) {
        res.getParent().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("request")) {
      JsonArray array = getJArray(json, "request");
      for (int i = 0; i < array.size(); i++) {
        res.getRequest().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("biologicalSourceEvent"))
      res.setBiologicalSourceEvent(parseIdentifier(getJObject(json, "biologicalSourceEvent")));
    if (json.has("processingFacility")) {
      JsonArray array = getJArray(json, "processingFacility");
      for (int i = 0; i < array.size(); i++) {
        res.getProcessingFacility().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("division"))
      res.setDivisionElement(parseString(json.get("division").getAsString()));
    if (json.has("_division"))
      parseElementProperties(getJObject(json, "_division"), res.getDivisionElement());
    if (json.has("productStatus"))
      res.setProductStatus(parseCoding(getJObject(json, "productStatus")));
    if (json.has("expirationDate"))
      res.setExpirationDateElement(parseDateTime(json.get("expirationDate").getAsString()));
    if (json.has("_expirationDate"))
      parseElementProperties(getJObject(json, "_expirationDate"), res.getExpirationDateElement());
    if (json.has("collection"))
      res.setCollection(parseBiologicallyDerivedProductCollectionComponent(getJObject(json, "collection")));
    if (json.has("storageTempRequirements"))
      res.setStorageTempRequirements(parseRange(getJObject(json, "storageTempRequirements")));
    if (json.has("property")) {
      JsonArray array = getJArray(json, "property");
      for (int i = 0; i < array.size(); i++) {
        res.getProperty().add(parseBiologicallyDerivedProductPropertyComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent parseBiologicallyDerivedProductCollectionComponent(JsonObject json) throws IOException, FHIRFormatError {
    BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent res = new BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent();
    parseBiologicallyDerivedProductCollectionComponentProperties(json, res);
    return res;
  }

  protected void parseBiologicallyDerivedProductCollectionComponentProperties(JsonObject json, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("collector"))
      res.setCollector(parseReference(getJObject(json, "collector")));
    if (json.has("source"))
      res.setSource(parseReference(getJObject(json, "source")));
    DataType collected = parseType("collected", json);
    if (collected != null)
      res.setCollected(collected);
  }

  protected BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent parseBiologicallyDerivedProductPropertyComponent(JsonObject json) throws IOException, FHIRFormatError {
    BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent res = new BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent();
    parseBiologicallyDerivedProductPropertyComponentProperties(json, res);
    return res;
  }

  protected void parseBiologicallyDerivedProductPropertyComponentProperties(JsonObject json, BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCoding(getJObject(json, "type")));
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected BodyStructure parseBodyStructure(JsonObject json) throws IOException, FHIRFormatError {
    BodyStructure res = new BodyStructure();
    parseBodyStructureProperties(json, res);
    return res;
  }

  protected void parseBodyStructureProperties(JsonObject json, BodyStructure res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_active"), res.getActiveElement());
    if (json.has("morphology"))
      res.setMorphology(parseCodeableConcept(getJObject(json, "morphology")));
    if (json.has("includedStructure")) {
      JsonArray array = getJArray(json, "includedStructure");
      for (int i = 0; i < array.size(); i++) {
        res.getIncludedStructure().add(parseBodyStructureIncludedStructureComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("excludedStructure")) {
      JsonArray array = getJArray(json, "excludedStructure");
      for (int i = 0; i < array.size(); i++) {
        res.getExcludedStructure().add(parseBodyStructureExcludedStructureComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("image")) {
      JsonArray array = getJArray(json, "image");
      for (int i = 0; i < array.size(); i++) {
        res.getImage().add(parseAttachment(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patient"))
      res.setPatient(parseReference(getJObject(json, "patient")));
  }

  protected BodyStructure.BodyStructureIncludedStructureComponent parseBodyStructureIncludedStructureComponent(JsonObject json) throws IOException, FHIRFormatError {
    BodyStructure.BodyStructureIncludedStructureComponent res = new BodyStructure.BodyStructureIncludedStructureComponent();
    parseBodyStructureIncludedStructureComponentProperties(json, res);
    return res;
  }

  protected void parseBodyStructureIncludedStructureComponentProperties(JsonObject json, BodyStructure.BodyStructureIncludedStructureComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("structure"))
      res.setStructure(parseCodeableConcept(getJObject(json, "structure")));
    if (json.has("laterality"))
      res.setLaterality(parseCodeableConcept(getJObject(json, "laterality")));
    if (json.has("qualifier")) {
      JsonArray array = getJArray(json, "qualifier");
      for (int i = 0; i < array.size(); i++) {
        res.getQualifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected BodyStructure.BodyStructureExcludedStructureComponent parseBodyStructureExcludedStructureComponent(JsonObject json) throws IOException, FHIRFormatError {
    BodyStructure.BodyStructureExcludedStructureComponent res = new BodyStructure.BodyStructureExcludedStructureComponent();
    parseBodyStructureExcludedStructureComponentProperties(json, res);
    return res;
  }

  protected void parseBodyStructureExcludedStructureComponentProperties(JsonObject json, BodyStructure.BodyStructureExcludedStructureComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("structure"))
      res.setStructure(parseCodeableConcept(getJObject(json, "structure")));
    if (json.has("laterality"))
      res.setLaterality(parseCodeableConcept(getJObject(json, "laterality")));
    if (json.has("qualifier")) {
      JsonArray array = getJArray(json, "qualifier");
      for (int i = 0; i < array.size(); i++) {
        res.getQualifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Bundle parseBundle(JsonObject json) throws IOException, FHIRFormatError {
    Bundle res = new Bundle();
    parseBundleProperties(json, res);
    return res;
  }

  protected void parseBundleProperties(JsonObject json, Bundle res) throws IOException, FHIRFormatError {
    parseResourceProperties(json, res);
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(getJObject(json, "identifier")));
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Bundle.BundleType.NULL, new Bundle.BundleTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("timestamp"))
      res.setTimestampElement(parseInstant(json.get("timestamp").getAsString()));
    if (json.has("_timestamp"))
      parseElementProperties(getJObject(json, "_timestamp"), res.getTimestampElement());
    if (json.has("total"))
      res.setTotalElement(parseUnsignedInt(json.get("total").getAsString()));
    if (json.has("_total"))
      parseElementProperties(getJObject(json, "_total"), res.getTotalElement());
    if (json.has("link")) {
      JsonArray array = getJArray(json, "link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseBundleLinkComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("entry")) {
      JsonArray array = getJArray(json, "entry");
      for (int i = 0; i < array.size(); i++) {
        res.getEntry().add(parseBundleEntryComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("signature"))
      res.setSignature(parseSignature(getJObject(json, "signature")));
    if (json.has("issues"))
      res.setIssues(parseResource(getJObject(json, "issues")));
  }

  protected Bundle.BundleLinkComponent parseBundleLinkComponent(JsonObject json) throws IOException, FHIRFormatError {
    Bundle.BundleLinkComponent res = new Bundle.BundleLinkComponent();
    parseBundleLinkComponentProperties(json, res);
    return res;
  }

  protected void parseBundleLinkComponentProperties(JsonObject json, Bundle.BundleLinkComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("relation"))
      res.setRelationElement(parseEnumeration(json.get("relation").getAsString(), Bundle.LinkRelationTypes.NULL, new Bundle.LinkRelationTypesEnumFactory()));
    if (json.has("_relation"))
      parseElementProperties(getJObject(json, "_relation"), res.getRelationElement());
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
  }

  protected Bundle.BundleEntryComponent parseBundleEntryComponent(JsonObject json) throws IOException, FHIRFormatError {
    Bundle.BundleEntryComponent res = new Bundle.BundleEntryComponent();
    parseBundleEntryComponentProperties(json, res);
    return res;
  }

  protected void parseBundleEntryComponentProperties(JsonObject json, Bundle.BundleEntryComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("link")) {
      JsonArray array = getJArray(json, "link");
      for (int i = 0; i < array.size(); i++) {
        res.getLink().add(parseBundleLinkComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("fullUrl"))
      res.setFullUrlElement(parseUri(json.get("fullUrl").getAsString()));
    if (json.has("_fullUrl"))
      parseElementProperties(getJObject(json, "_fullUrl"), res.getFullUrlElement());
    if (json.has("resource"))
      res.setResource(parseResource(getJObject(json, "resource")));
    if (json.has("search"))
      res.setSearch(parseBundleEntrySearchComponent(getJObject(json, "search")));
    if (json.has("request"))
      res.setRequest(parseBundleEntryRequestComponent(getJObject(json, "request")));
    if (json.has("response"))
      res.setResponse(parseBundleEntryResponseComponent(getJObject(json, "response")));
  }

  protected Bundle.BundleEntrySearchComponent parseBundleEntrySearchComponent(JsonObject json) throws IOException, FHIRFormatError {
    Bundle.BundleEntrySearchComponent res = new Bundle.BundleEntrySearchComponent();
    parseBundleEntrySearchComponentProperties(json, res);
    return res;
  }

  protected void parseBundleEntrySearchComponentProperties(JsonObject json, Bundle.BundleEntrySearchComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), Bundle.SearchEntryMode.NULL, new Bundle.SearchEntryModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(getJObject(json, "_mode"), res.getModeElement());
    if (json.has("score"))
      res.setScoreElement(parseDecimal(json.get("score").getAsBigDecimal()));
    if (json.has("_score"))
      parseElementProperties(getJObject(json, "_score"), res.getScoreElement());
  }

  protected Bundle.BundleEntryRequestComponent parseBundleEntryRequestComponent(JsonObject json) throws IOException, FHIRFormatError {
    Bundle.BundleEntryRequestComponent res = new Bundle.BundleEntryRequestComponent();
    parseBundleEntryRequestComponentProperties(json, res);
    return res;
  }

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

  protected Bundle.BundleEntryResponseComponent parseBundleEntryResponseComponent(JsonObject json) throws IOException, FHIRFormatError {
    Bundle.BundleEntryResponseComponent res = new Bundle.BundleEntryResponseComponent();
    parseBundleEntryResponseComponentProperties(json, res);
    return res;
  }

  protected void parseBundleEntryResponseComponentProperties(JsonObject json, Bundle.BundleEntryResponseComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("status"))
      res.setStatusElement(parseString(json.get("status").getAsString()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("location"))
      res.setLocationElement(parseUri(json.get("location").getAsString()));
    if (json.has("_location"))
      parseElementProperties(getJObject(json, "_location"), res.getLocationElement());
    if (json.has("etag"))
      res.setEtagElement(parseString(json.get("etag").getAsString()));
    if (json.has("_etag"))
      parseElementProperties(getJObject(json, "_etag"), res.getEtagElement());
    if (json.has("lastModified"))
      res.setLastModifiedElement(parseInstant(json.get("lastModified").getAsString()));
    if (json.has("_lastModified"))
      parseElementProperties(getJObject(json, "_lastModified"), res.getLastModifiedElement());
    if (json.has("outcome"))
      res.setOutcome(parseResource(getJObject(json, "outcome")));
  }

  protected CapabilityStatement parseCapabilityStatement(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement res = new CapabilityStatement();
    parseCapabilityStatementProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementProperties(JsonObject json, CapabilityStatement res) throws IOException, FHIRFormatError {
    parseCanonicalResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(getJObject(json, "_version"), res.getVersionElement());
    DataType versionAlgorithm = parseType("versionAlgorithm", json);
    if (versionAlgorithm != null)
      res.setVersionAlgorithm(versionAlgorithm);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("copyrightLabel"))
      res.setCopyrightLabelElement(parseString(json.get("copyrightLabel").getAsString()));
    if (json.has("_copyrightLabel"))
      parseElementProperties(getJObject(json, "_copyrightLabel"), res.getCopyrightLabelElement());
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), Enumerations.CapabilityStatementKind.NULL, new Enumerations.CapabilityStatementKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(getJObject(json, "_kind"), res.getKindElement());
    if (json.has("instantiates")) {
      JsonArray array = getJArray(json, "instantiates");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiates().add(new CanonicalType());
        } else {;
          res.getInstantiates().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiates")) {
      JsonArray array = getJArray(json, "_instantiates");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiates().size())
          res.getInstantiates().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiates().get(i));
      }
    };
    if (json.has("imports")) {
      JsonArray array = getJArray(json, "imports");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getImports().add(new CanonicalType());
        } else {;
          res.getImports().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_imports")) {
      JsonArray array = getJArray(json, "_imports");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getImports().size())
          res.getImports().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getImports().get(i));
      }
    };
    if (json.has("software"))
      res.setSoftware(parseCapabilityStatementSoftwareComponent(getJObject(json, "software")));
    if (json.has("implementation"))
      res.setImplementation(parseCapabilityStatementImplementationComponent(getJObject(json, "implementation")));
    if (json.has("fhirVersion"))
      res.setFhirVersionElement(parseEnumeration(json.get("fhirVersion").getAsString(), Enumerations.FHIRVersion.NULL, new Enumerations.FHIRVersionEnumFactory()));
    if (json.has("_fhirVersion"))
      parseElementProperties(getJObject(json, "_fhirVersion"), res.getFhirVersionElement());
    if (json.has("format")) {
      JsonArray array = getJArray(json, "format");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getFormat().add(new CodeType());
        } else {;
          res.getFormat().add(parseCode(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_format")) {
      JsonArray array = getJArray(json, "_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("patchFormat")) {
      JsonArray array = getJArray(json, "patchFormat");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPatchFormat().add(new CodeType());
        } else {;
          res.getPatchFormat().add(parseCode(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_patchFormat")) {
      JsonArray array = getJArray(json, "_patchFormat");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPatchFormat().size())
          res.getPatchFormat().add(parseCode(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPatchFormat().get(i));
      }
    };
    if (json.has("acceptLanguage")) {
      JsonArray array = getJArray(json, "acceptLanguage");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getAcceptLanguage().add(new CodeType());
        } else {;
          res.getAcceptLanguage().add(parseCode(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_acceptLanguage")) {
      JsonArray array = getJArray(json, "_acceptLanguage");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getAcceptLanguage().size())
          res.getAcceptLanguage().add(parseCode(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getAcceptLanguage().get(i));
      }
    };
    if (json.has("implementationGuide")) {
      JsonArray array = getJArray(json, "implementationGuide");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getImplementationGuide().add(new CanonicalType());
        } else {;
          res.getImplementationGuide().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_implementationGuide")) {
      JsonArray array = getJArray(json, "_implementationGuide");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getImplementationGuide().size())
          res.getImplementationGuide().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getImplementationGuide().get(i));
      }
    };
    if (json.has("rest")) {
      JsonArray array = getJArray(json, "rest");
      for (int i = 0; i < array.size(); i++) {
        res.getRest().add(parseCapabilityStatementRestComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("messaging")) {
      JsonArray array = getJArray(json, "messaging");
      for (int i = 0; i < array.size(); i++) {
        res.getMessaging().add(parseCapabilityStatementMessagingComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("document")) {
      JsonArray array = getJArray(json, "document");
      for (int i = 0; i < array.size(); i++) {
        res.getDocument().add(parseCapabilityStatementDocumentComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CapabilityStatement.CapabilityStatementSoftwareComponent parseCapabilityStatementSoftwareComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementSoftwareComponent res = new CapabilityStatement.CapabilityStatementSoftwareComponent();
    parseCapabilityStatementSoftwareComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementSoftwareComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementSoftwareComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("releaseDate"))
      res.setReleaseDateElement(parseDateTime(json.get("releaseDate").getAsString()));
    if (json.has("_releaseDate"))
      parseElementProperties(getJObject(json, "_releaseDate"), res.getReleaseDateElement());
  }

  protected CapabilityStatement.CapabilityStatementImplementationComponent parseCapabilityStatementImplementationComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementImplementationComponent res = new CapabilityStatement.CapabilityStatementImplementationComponent();
    parseCapabilityStatementImplementationComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementImplementationComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementImplementationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("url"))
      res.setUrlElement(parseUrl(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("custodian"))
      res.setCustodian(parseReference(getJObject(json, "custodian")));
  }

  protected CapabilityStatement.CapabilityStatementRestComponent parseCapabilityStatementRestComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementRestComponent res = new CapabilityStatement.CapabilityStatementRestComponent();
    parseCapabilityStatementRestComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementRestComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementRestComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), CapabilityStatement.RestfulCapabilityMode.NULL, new CapabilityStatement.RestfulCapabilityModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(getJObject(json, "_mode"), res.getModeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("security"))
      res.setSecurity(parseCapabilityStatementRestSecurityComponent(getJObject(json, "security")));
    if (json.has("resource")) {
      JsonArray array = getJArray(json, "resource");
      for (int i = 0; i < array.size(); i++) {
        res.getResource().add(parseCapabilityStatementRestResourceComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("interaction")) {
      JsonArray array = getJArray(json, "interaction");
      for (int i = 0; i < array.size(); i++) {
        res.getInteraction().add(parseCapabilityStatementSystemInteractionComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("searchParam")) {
      JsonArray array = getJArray(json, "searchParam");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchParam().add(parseCapabilityStatementRestResourceSearchParamComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("operation")) {
      JsonArray array = getJArray(json, "operation");
      for (int i = 0; i < array.size(); i++) {
        res.getOperation().add(parseCapabilityStatementRestResourceOperationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("compartment")) {
      JsonArray array = getJArray(json, "compartment");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getCompartment().add(new CanonicalType());
        } else {;
          res.getCompartment().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_compartment")) {
      JsonArray array = getJArray(json, "_compartment");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getCompartment().size())
          res.getCompartment().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getCompartment().get(i));
      }
    };
  }

  protected CapabilityStatement.CapabilityStatementRestSecurityComponent parseCapabilityStatementRestSecurityComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementRestSecurityComponent res = new CapabilityStatement.CapabilityStatementRestSecurityComponent();
    parseCapabilityStatementRestSecurityComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementRestSecurityComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementRestSecurityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("cors"))
      res.setCorsElement(parseBoolean(json.get("cors").getAsBoolean()));
    if (json.has("_cors"))
      parseElementProperties(getJObject(json, "_cors"), res.getCorsElement());
    if (json.has("service")) {
      JsonArray array = getJArray(json, "service");
      for (int i = 0; i < array.size(); i++) {
        res.getService().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
  }

  protected CapabilityStatement.CapabilityStatementRestResourceComponent parseCapabilityStatementRestResourceComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementRestResourceComponent res = new CapabilityStatement.CapabilityStatementRestResourceComponent();
    parseCapabilityStatementRestResourceComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementRestResourceComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementRestResourceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseCode(json.get("type").getAsString()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("profile"))
      res.setProfileElement(parseCanonical(json.get("profile").getAsString()));
    if (json.has("_profile"))
      parseElementProperties(getJObject(json, "_profile"), res.getProfileElement());
    if (json.has("supportedProfile")) {
      JsonArray array = getJArray(json, "supportedProfile");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSupportedProfile().add(new CanonicalType());
        } else {;
          res.getSupportedProfile().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_supportedProfile")) {
      JsonArray array = getJArray(json, "_supportedProfile");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSupportedProfile().size())
          res.getSupportedProfile().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSupportedProfile().get(i));
      }
    };
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("interaction")) {
      JsonArray array = getJArray(json, "interaction");
      for (int i = 0; i < array.size(); i++) {
        res.getInteraction().add(parseCapabilityStatementResourceInteractionComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("versioning"))
      res.setVersioningElement(parseEnumeration(json.get("versioning").getAsString(), CapabilityStatement.ResourceVersionPolicy.NULL, new CapabilityStatement.ResourceVersionPolicyEnumFactory()));
    if (json.has("_versioning"))
      parseElementProperties(getJObject(json, "_versioning"), res.getVersioningElement());
    if (json.has("readHistory"))
      res.setReadHistoryElement(parseBoolean(json.get("readHistory").getAsBoolean()));
    if (json.has("_readHistory"))
      parseElementProperties(getJObject(json, "_readHistory"), res.getReadHistoryElement());
    if (json.has("updateCreate"))
      res.setUpdateCreateElement(parseBoolean(json.get("updateCreate").getAsBoolean()));
    if (json.has("_updateCreate"))
      parseElementProperties(getJObject(json, "_updateCreate"), res.getUpdateCreateElement());
    if (json.has("conditionalCreate"))
      res.setConditionalCreateElement(parseBoolean(json.get("conditionalCreate").getAsBoolean()));
    if (json.has("_conditionalCreate"))
      parseElementProperties(getJObject(json, "_conditionalCreate"), res.getConditionalCreateElement());
    if (json.has("conditionalRead"))
      res.setConditionalReadElement(parseEnumeration(json.get("conditionalRead").getAsString(), CapabilityStatement.ConditionalReadStatus.NULL, new CapabilityStatement.ConditionalReadStatusEnumFactory()));
    if (json.has("_conditionalRead"))
      parseElementProperties(getJObject(json, "_conditionalRead"), res.getConditionalReadElement());
    if (json.has("conditionalUpdate"))
      res.setConditionalUpdateElement(parseBoolean(json.get("conditionalUpdate").getAsBoolean()));
    if (json.has("_conditionalUpdate"))
      parseElementProperties(getJObject(json, "_conditionalUpdate"), res.getConditionalUpdateElement());
    if (json.has("conditionalPatch"))
      res.setConditionalPatchElement(parseBoolean(json.get("conditionalPatch").getAsBoolean()));
    if (json.has("_conditionalPatch"))
      parseElementProperties(getJObject(json, "_conditionalPatch"), res.getConditionalPatchElement());
    if (json.has("conditionalDelete"))
      res.setConditionalDeleteElement(parseEnumeration(json.get("conditionalDelete").getAsString(), CapabilityStatement.ConditionalDeleteStatus.NULL, new CapabilityStatement.ConditionalDeleteStatusEnumFactory()));
    if (json.has("_conditionalDelete"))
      parseElementProperties(getJObject(json, "_conditionalDelete"), res.getConditionalDeleteElement());
    if (json.has("referencePolicy")) {
      JsonArray array = getJArray(json, "referencePolicy");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getReferencePolicy().add(new Enumeration<CapabilityStatement.ReferenceHandlingPolicy>(new CapabilityStatement.ReferenceHandlingPolicyEnumFactory(), CapabilityStatement.ReferenceHandlingPolicy.NULL));
        } else {;
          res.getReferencePolicy().add(parseEnumeration(array.get(i).getAsString(), CapabilityStatement.ReferenceHandlingPolicy.NULL, new CapabilityStatement.ReferenceHandlingPolicyEnumFactory()));
        }
      }
    };
    if (json.has("_referencePolicy")) {
      JsonArray array = getJArray(json, "_referencePolicy");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getReferencePolicy().size())
          res.getReferencePolicy().add(parseEnumeration(null, CapabilityStatement.ReferenceHandlingPolicy.NULL, new CapabilityStatement.ReferenceHandlingPolicyEnumFactory()));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getReferencePolicy().get(i));
      }
    };
    if (json.has("searchInclude")) {
      JsonArray array = getJArray(json, "searchInclude");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSearchInclude().add(new StringType());
        } else {;
          res.getSearchInclude().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_searchInclude")) {
      JsonArray array = getJArray(json, "_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 = getJArray(json, "searchRevInclude");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSearchRevInclude().add(new StringType());
        } else {;
          res.getSearchRevInclude().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_searchRevInclude")) {
      JsonArray array = getJArray(json, "_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 = getJArray(json, "searchParam");
      for (int i = 0; i < array.size(); i++) {
        res.getSearchParam().add(parseCapabilityStatementRestResourceSearchParamComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("operation")) {
      JsonArray array = getJArray(json, "operation");
      for (int i = 0; i < array.size(); i++) {
        res.getOperation().add(parseCapabilityStatementRestResourceOperationComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CapabilityStatement.ResourceInteractionComponent parseCapabilityStatementResourceInteractionComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.ResourceInteractionComponent res = new CapabilityStatement.ResourceInteractionComponent();
    parseCapabilityStatementResourceInteractionComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementResourceInteractionComponentProperties(JsonObject json, CapabilityStatement.ResourceInteractionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), CapabilityStatement.TypeRestfulInteraction.NULL, new CapabilityStatement.TypeRestfulInteractionEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
  }

  protected CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent parseCapabilityStatementRestResourceSearchParamComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent res = new CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent();
    parseCapabilityStatementRestResourceSearchParamComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementRestResourceSearchParamComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseCanonical(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(getJObject(json, "_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(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
  }

  protected CapabilityStatement.CapabilityStatementRestResourceOperationComponent parseCapabilityStatementRestResourceOperationComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementRestResourceOperationComponent res = new CapabilityStatement.CapabilityStatementRestResourceOperationComponent();
    parseCapabilityStatementRestResourceOperationComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementRestResourceOperationComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementRestResourceOperationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseCanonical(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(getJObject(json, "_definition"), res.getDefinitionElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
  }

  protected CapabilityStatement.SystemInteractionComponent parseCapabilityStatementSystemInteractionComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.SystemInteractionComponent res = new CapabilityStatement.SystemInteractionComponent();
    parseCapabilityStatementSystemInteractionComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementSystemInteractionComponentProperties(JsonObject json, CapabilityStatement.SystemInteractionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), CapabilityStatement.SystemRestfulInteraction.NULL, new CapabilityStatement.SystemRestfulInteractionEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
  }

  protected CapabilityStatement.CapabilityStatementMessagingComponent parseCapabilityStatementMessagingComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementMessagingComponent res = new CapabilityStatement.CapabilityStatementMessagingComponent();
    parseCapabilityStatementMessagingComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementMessagingComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementMessagingComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("endpoint")) {
      JsonArray array = getJArray(json, "endpoint");
      for (int i = 0; i < array.size(); i++) {
        res.getEndpoint().add(parseCapabilityStatementMessagingEndpointComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reliableCache"))
      res.setReliableCacheElement(parseUnsignedInt(json.get("reliableCache").getAsString()));
    if (json.has("_reliableCache"))
      parseElementProperties(getJObject(json, "_reliableCache"), res.getReliableCacheElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("supportedMessage")) {
      JsonArray array = getJArray(json, "supportedMessage");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportedMessage().add(parseCapabilityStatementMessagingSupportedMessageComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CapabilityStatement.CapabilityStatementMessagingEndpointComponent parseCapabilityStatementMessagingEndpointComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementMessagingEndpointComponent res = new CapabilityStatement.CapabilityStatementMessagingEndpointComponent();
    parseCapabilityStatementMessagingEndpointComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementMessagingEndpointComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementMessagingEndpointComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("protocol"))
      res.setProtocol(parseCoding(getJObject(json, "protocol")));
    if (json.has("address"))
      res.setAddressElement(parseUrl(json.get("address").getAsString()));
    if (json.has("_address"))
      parseElementProperties(getJObject(json, "_address"), res.getAddressElement());
  }

  protected CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent parseCapabilityStatementMessagingSupportedMessageComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent res = new CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent();
    parseCapabilityStatementMessagingSupportedMessageComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementMessagingSupportedMessageComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), CapabilityStatement.EventCapabilityMode.NULL, new CapabilityStatement.EventCapabilityModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(getJObject(json, "_mode"), res.getModeElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseCanonical(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(getJObject(json, "_definition"), res.getDefinitionElement());
  }

  protected CapabilityStatement.CapabilityStatementDocumentComponent parseCapabilityStatementDocumentComponent(JsonObject json) throws IOException, FHIRFormatError {
    CapabilityStatement.CapabilityStatementDocumentComponent res = new CapabilityStatement.CapabilityStatementDocumentComponent();
    parseCapabilityStatementDocumentComponentProperties(json, res);
    return res;
  }

  protected void parseCapabilityStatementDocumentComponentProperties(JsonObject json, CapabilityStatement.CapabilityStatementDocumentComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("mode"))
      res.setModeElement(parseEnumeration(json.get("mode").getAsString(), CapabilityStatement.DocumentMode.NULL, new CapabilityStatement.DocumentModeEnumFactory()));
    if (json.has("_mode"))
      parseElementProperties(getJObject(json, "_mode"), res.getModeElement());
    if (json.has("documentation"))
      res.setDocumentationElement(parseMarkdown(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("profile"))
      res.setProfileElement(parseCanonical(json.get("profile").getAsString()));
    if (json.has("_profile"))
      parseElementProperties(getJObject(json, "_profile"), res.getProfileElement());
  }

  protected CarePlan parseCarePlan(JsonObject json) throws IOException, FHIRFormatError {
    CarePlan res = new CarePlan();
    parseCarePlanProperties(json, res);
    return res;
  }

  protected void parseCarePlanProperties(JsonObject json, CarePlan res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("instantiatesCanonical")) {
      JsonArray array = getJArray(json, "instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesCanonical().add(new CanonicalType());
        } else {;
          res.getInstantiatesCanonical().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesCanonical")) {
      JsonArray array = getJArray(json, "_instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesCanonical().size())
          res.getInstantiatesCanonical().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesCanonical().get(i));
      }
    };
    if (json.has("instantiatesUri")) {
      JsonArray array = getJArray(json, "instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesUri().add(new UriType());
        } else {;
          res.getInstantiatesUri().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesUri")) {
      JsonArray array = getJArray(json, "_instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesUri().size())
          res.getInstantiatesUri().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesUri().get(i));
      }
    };
    if (json.has("basedOn")) {
      JsonArray array = getJArray(json, "basedOn");
      for (int i = 0; i < array.size(); i++) {
        res.getBasedOn().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("replaces")) {
      JsonArray array = getJArray(json, "replaces");
      for (int i = 0; i < array.size(); i++) {
        res.getReplaces().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("partOf")) {
      JsonArray array = getJArray(json, "partOf");
      for (int i = 0; i < array.size(); i++) {
        res.getPartOf().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.RequestStatus.NULL, new Enumerations.RequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("intent"))
      res.setIntentElement(parseEnumeration(json.get("intent").getAsString(), CarePlan.CarePlanIntent.NULL, new CarePlan.CarePlanIntentEnumFactory()));
    if (json.has("_intent"))
      parseElementProperties(getJObject(json, "_intent"), res.getIntentElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(getJObject(json, "_created"), res.getCreatedElement());
    if (json.has("custodian"))
      res.setCustodian(parseReference(getJObject(json, "custodian")));
    if (json.has("contributor")) {
      JsonArray array = getJArray(json, "contributor");
      for (int i = 0; i < array.size(); i++) {
        res.getContributor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("careTeam")) {
      JsonArray array = getJArray(json, "careTeam");
      for (int i = 0; i < array.size(); i++) {
        res.getCareTeam().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("addresses")) {
      JsonArray array = getJArray(json, "addresses");
      for (int i = 0; i < array.size(); i++) {
        res.getAddresses().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInfo")) {
      JsonArray array = getJArray(json, "supportingInfo");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInfo().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("goal")) {
      JsonArray array = getJArray(json, "goal");
      for (int i = 0; i < array.size(); i++) {
        res.getGoal().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("activity")) {
      JsonArray array = getJArray(json, "activity");
      for (int i = 0; i < array.size(); i++) {
        res.getActivity().add(parseCarePlanActivityComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CarePlan.CarePlanActivityComponent parseCarePlanActivityComponent(JsonObject json) throws IOException, FHIRFormatError {
    CarePlan.CarePlanActivityComponent res = new CarePlan.CarePlanActivityComponent();
    parseCarePlanActivityComponentProperties(json, res);
    return res;
  }

  protected void parseCarePlanActivityComponentProperties(JsonObject json, CarePlan.CarePlanActivityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("performedActivity")) {
      JsonArray array = getJArray(json, "performedActivity");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformedActivity().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("progress")) {
      JsonArray array = getJArray(json, "progress");
      for (int i = 0; i < array.size(); i++) {
        res.getProgress().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("plannedActivityReference"))
      res.setPlannedActivityReference(parseReference(getJObject(json, "plannedActivityReference")));
    if (json.has("plannedActivityDetail"))
      res.setPlannedActivityDetail(parseCarePlanActivityPlannedActivityDetailComponent(getJObject(json, "plannedActivityDetail")));
  }

  protected CarePlan.CarePlanActivityPlannedActivityDetailComponent parseCarePlanActivityPlannedActivityDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    CarePlan.CarePlanActivityPlannedActivityDetailComponent res = new CarePlan.CarePlanActivityPlannedActivityDetailComponent();
    parseCarePlanActivityPlannedActivityDetailComponentProperties(json, res);
    return res;
  }

  protected void parseCarePlanActivityPlannedActivityDetailComponentProperties(JsonObject json, CarePlan.CarePlanActivityPlannedActivityDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("kind"))
      res.setKindElement(parseEnumeration(json.get("kind").getAsString(), CarePlan.CarePlanActivityKind.NULL, new CarePlan.CarePlanActivityKindEnumFactory()));
    if (json.has("_kind"))
      parseElementProperties(getJObject(json, "_kind"), res.getKindElement());
    if (json.has("instantiatesCanonical")) {
      JsonArray array = getJArray(json, "instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesCanonical().add(new CanonicalType());
        } else {;
          res.getInstantiatesCanonical().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesCanonical")) {
      JsonArray array = getJArray(json, "_instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesCanonical().size())
          res.getInstantiatesCanonical().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesCanonical().get(i));
      }
    };
    if (json.has("instantiatesUri")) {
      JsonArray array = getJArray(json, "instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesUri().add(new UriType());
        } else {;
          res.getInstantiatesUri().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesUri")) {
      JsonArray array = getJArray(json, "_instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesUri().size())
          res.getInstantiatesUri().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesUri().get(i));
      }
    };
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("goal")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(getJObject(json, "statusReason")));
    if (json.has("doNotPerform"))
      res.setDoNotPerformElement(parseBoolean(json.get("doNotPerform").getAsBoolean()));
    if (json.has("_doNotPerform"))
      parseElementProperties(getJObject(json, "_doNotPerform"), res.getDoNotPerformElement());
    DataType scheduled = parseType("scheduled", json);
    if (scheduled != null)
      res.setScheduled(scheduled);
    if (json.has("location"))
      res.setLocation(parseCodeableReference(getJObject(json, "location")));
    DataType reported = parseType("reported", json);
    if (reported != null)
      res.setReported(reported);
    if (json.has("performer")) {
      JsonArray array = getJArray(json, "performer");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformer().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    DataType product = parseType("product", json);
    if (product != null)
      res.setProduct(product);
    if (json.has("dailyAmount"))
      res.setDailyAmount(parseQuantity(getJObject(json, "dailyAmount")));
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
  }

  protected CareTeam parseCareTeam(JsonObject json) throws IOException, FHIRFormatError {
    CareTeam res = new CareTeam();
    parseCareTeamProperties(json, res);
    return res;
  }

  protected void parseCareTeamProperties(JsonObject json, CareTeam res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), CareTeam.CareTeamStatus.NULL, new CareTeam.CareTeamStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
    if (json.has("participant")) {
      JsonArray array = getJArray(json, "participant");
      for (int i = 0; i < array.size(); i++) {
        res.getParticipant().add(parseCareTeamParticipantComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("managingOrganization")) {
      JsonArray array = getJArray(json, "managingOrganization");
      for (int i = 0; i < array.size(); i++) {
        res.getManagingOrganization().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("telecom")) {
      JsonArray array = getJArray(json, "telecom");
      for (int i = 0; i < array.size(); i++) {
        res.getTelecom().add(parseContactPoint(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CareTeam.CareTeamParticipantComponent parseCareTeamParticipantComponent(JsonObject json) throws IOException, FHIRFormatError {
    CareTeam.CareTeamParticipantComponent res = new CareTeam.CareTeamParticipantComponent();
    parseCareTeamParticipantComponentProperties(json, res);
    return res;
  }

  protected void parseCareTeamParticipantComponentProperties(JsonObject json, CareTeam.CareTeamParticipantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("role"))
      res.setRole(parseCodeableConcept(getJObject(json, "role")));
    if (json.has("member"))
      res.setMember(parseReference(getJObject(json, "member")));
    if (json.has("onBehalfOf"))
      res.setOnBehalfOf(parseReference(getJObject(json, "onBehalfOf")));
    DataType coverage = parseType("coverage", json);
    if (coverage != null)
      res.setCoverage(coverage);
  }

  protected ChargeItem parseChargeItem(JsonObject json) throws IOException, FHIRFormatError {
    ChargeItem res = new ChargeItem();
    parseChargeItemProperties(json, res);
    return res;
  }

  protected void parseChargeItemProperties(JsonObject json, ChargeItem res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("definitionUri")) {
      JsonArray array = getJArray(json, "definitionUri");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDefinitionUri().add(new UriType());
        } else {;
          res.getDefinitionUri().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_definitionUri")) {
      JsonArray array = getJArray(json, "_definitionUri");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDefinitionUri().size())
          res.getDefinitionUri().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDefinitionUri().get(i));
      }
    };
    if (json.has("definitionCanonical")) {
      JsonArray array = getJArray(json, "definitionCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDefinitionCanonical().add(new CanonicalType());
        } else {;
          res.getDefinitionCanonical().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_definitionCanonical")) {
      JsonArray array = getJArray(json, "_definitionCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDefinitionCanonical().size())
          res.getDefinitionCanonical().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDefinitionCanonical().get(i));
      }
    };
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), ChargeItem.ChargeItemStatus.NULL, new ChargeItem.ChargeItemStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("partOf")) {
      JsonArray array = getJArray(json, "partOf");
      for (int i = 0; i < array.size(); i++) {
        res.getPartOf().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    DataType occurrence = parseType("occurrence", json);
    if (occurrence != null)
      res.setOccurrence(occurrence);
    if (json.has("performer")) {
      JsonArray array = getJArray(json, "performer");
      for (int i = 0; i < array.size(); i++) {
        res.getPerformer().add(parseChargeItemPerformerComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("performingOrganization"))
      res.setPerformingOrganization(parseReference(getJObject(json, "performingOrganization")));
    if (json.has("requestingOrganization"))
      res.setRequestingOrganization(parseReference(getJObject(json, "requestingOrganization")));
    if (json.has("costCenter"))
      res.setCostCenter(parseReference(getJObject(json, "costCenter")));
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("bodysite")) {
      JsonArray array = getJArray(json, "bodysite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodysite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("unitPriceComponent"))
      res.setUnitPriceComponent(parseMonetaryComponent(getJObject(json, "unitPriceComponent")));
    if (json.has("totalPriceComponent"))
      res.setTotalPriceComponent(parseMonetaryComponent(getJObject(json, "totalPriceComponent")));
    if (json.has("overrideReason"))
      res.setOverrideReason(parseCodeableConcept(getJObject(json, "overrideReason")));
    if (json.has("enterer"))
      res.setEnterer(parseReference(getJObject(json, "enterer")));
    if (json.has("enteredDate"))
      res.setEnteredDateElement(parseDateTime(json.get("enteredDate").getAsString()));
    if (json.has("_enteredDate"))
      parseElementProperties(getJObject(json, "_enteredDate"), res.getEnteredDateElement());
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("service")) {
      JsonArray array = getJArray(json, "service");
      for (int i = 0; i < array.size(); i++) {
        res.getService().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("product")) {
      JsonArray array = getJArray(json, "product");
      for (int i = 0; i < array.size(); i++) {
        res.getProduct().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("account")) {
      JsonArray array = getJArray(json, "account");
      for (int i = 0; i < array.size(); i++) {
        res.getAccount().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInformation")) {
      JsonArray array = getJArray(json, "supportingInformation");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInformation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ChargeItem.ChargeItemPerformerComponent parseChargeItemPerformerComponent(JsonObject json) throws IOException, FHIRFormatError {
    ChargeItem.ChargeItemPerformerComponent res = new ChargeItem.ChargeItemPerformerComponent();
    parseChargeItemPerformerComponentProperties(json, res);
    return res;
  }

  protected void parseChargeItemPerformerComponentProperties(JsonObject json, ChargeItem.ChargeItemPerformerComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("function"))
      res.setFunction(parseCodeableConcept(getJObject(json, "function")));
    if (json.has("actor"))
      res.setActor(parseReference(getJObject(json, "actor")));
  }

  protected ChargeItemDefinition parseChargeItemDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ChargeItemDefinition res = new ChargeItemDefinition();
    parseChargeItemDefinitionProperties(json, res);
    return res;
  }

  protected void parseChargeItemDefinitionProperties(JsonObject json, ChargeItemDefinition res) throws IOException, FHIRFormatError {
    parseMetadataResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("derivedFromUri")) {
      JsonArray array = getJArray(json, "derivedFromUri");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDerivedFromUri().add(new UriType());
        } else {;
          res.getDerivedFromUri().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_derivedFromUri")) {
      JsonArray array = getJArray(json, "_derivedFromUri");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDerivedFromUri().size())
          res.getDerivedFromUri().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDerivedFromUri().get(i));
      }
    };
    if (json.has("partOf")) {
      JsonArray array = getJArray(json, "partOf");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPartOf().add(new CanonicalType());
        } else {;
          res.getPartOf().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_partOf")) {
      JsonArray array = getJArray(json, "_partOf");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getPartOf().size())
          res.getPartOf().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getPartOf().get(i));
      }
    };
    if (json.has("replaces")) {
      JsonArray array = getJArray(json, "replaces");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getReplaces().add(new CanonicalType());
        } else {;
          res.getReplaces().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_replaces")) {
      JsonArray array = getJArray(json, "_replaces");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getReplaces().size())
          res.getReplaces().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getReplaces().get(i));
      }
    };
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("approvalDate"))
      res.setApprovalDateElement(parseDate(json.get("approvalDate").getAsString()));
    if (json.has("_approvalDate"))
      parseElementProperties(getJObject(json, "_approvalDate"), res.getApprovalDateElement());
    if (json.has("lastReviewDate"))
      res.setLastReviewDateElement(parseDate(json.get("lastReviewDate").getAsString()));
    if (json.has("_lastReviewDate"))
      parseElementProperties(getJObject(json, "_lastReviewDate"), res.getLastReviewDateElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    if (json.has("instance")) {
      JsonArray array = getJArray(json, "instance");
      for (int i = 0; i < array.size(); i++) {
        res.getInstance().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("applicability")) {
      JsonArray array = getJArray(json, "applicability");
      for (int i = 0; i < array.size(); i++) {
        res.getApplicability().add(parseChargeItemDefinitionApplicabilityComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("propertyGroup")) {
      JsonArray array = getJArray(json, "propertyGroup");
      for (int i = 0; i < array.size(); i++) {
        res.getPropertyGroup().add(parseChargeItemDefinitionPropertyGroupComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent parseChargeItemDefinitionApplicabilityComponent(JsonObject json) throws IOException, FHIRFormatError {
    ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent res = new ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent();
    parseChargeItemDefinitionApplicabilityComponentProperties(json, res);
    return res;
  }

  protected void parseChargeItemDefinitionApplicabilityComponentProperties(JsonObject json, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("condition"))
      res.setCondition(parseExpression(getJObject(json, "condition")));
    if (json.has("effectivePeriod"))
      res.setEffectivePeriod(parsePeriod(getJObject(json, "effectivePeriod")));
    if (json.has("relatedArtifact"))
      res.setRelatedArtifact(parseRelatedArtifact(getJObject(json, "relatedArtifact")));
  }

  protected ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent parseChargeItemDefinitionPropertyGroupComponent(JsonObject json) throws IOException, FHIRFormatError {
    ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent res = new ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent();
    parseChargeItemDefinitionPropertyGroupComponentProperties(json, res);
    return res;
  }

  protected void parseChargeItemDefinitionPropertyGroupComponentProperties(JsonObject json, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("applicability")) {
      JsonArray array = getJArray(json, "applicability");
      for (int i = 0; i < array.size(); i++) {
        res.getApplicability().add(parseChargeItemDefinitionApplicabilityComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("priceComponent")) {
      JsonArray array = getJArray(json, "priceComponent");
      for (int i = 0; i < array.size(); i++) {
        res.getPriceComponent().add(parseMonetaryComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Citation parseCitation(JsonObject json) throws IOException, FHIRFormatError {
    Citation res = new Citation();
    parseCitationProperties(json, res);
    return res;
  }

  protected void parseCitationProperties(JsonObject json, Citation res) throws IOException, FHIRFormatError {
    parseMetadataResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("approvalDate"))
      res.setApprovalDateElement(parseDate(json.get("approvalDate").getAsString()));
    if (json.has("_approvalDate"))
      parseElementProperties(getJObject(json, "_approvalDate"), res.getApprovalDateElement());
    if (json.has("lastReviewDate"))
      res.setLastReviewDateElement(parseDate(json.get("lastReviewDate").getAsString()));
    if (json.has("_lastReviewDate"))
      parseElementProperties(getJObject(json, "_lastReviewDate"), res.getLastReviewDateElement());
    if (json.has("effectivePeriod"))
      res.setEffectivePeriod(parsePeriod(getJObject(json, "effectivePeriod")));
    if (json.has("author")) {
      JsonArray array = getJArray(json, "author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("editor")) {
      JsonArray array = getJArray(json, "editor");
      for (int i = 0; i < array.size(); i++) {
        res.getEditor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reviewer")) {
      JsonArray array = getJArray(json, "reviewer");
      for (int i = 0; i < array.size(); i++) {
        res.getReviewer().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("endorser")) {
      JsonArray array = getJArray(json, "endorser");
      for (int i = 0; i < array.size(); i++) {
        res.getEndorser().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("summary")) {
      JsonArray array = getJArray(json, "summary");
      for (int i = 0; i < array.size(); i++) {
        res.getSummary().add(parseCitationSummaryComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("classification")) {
      JsonArray array = getJArray(json, "classification");
      for (int i = 0; i < array.size(); i++) {
        res.getClassification().add(parseCitationClassificationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("currentState")) {
      JsonArray array = getJArray(json, "currentState");
      for (int i = 0; i < array.size(); i++) {
        res.getCurrentState().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("statusDate")) {
      JsonArray array = getJArray(json, "statusDate");
      for (int i = 0; i < array.size(); i++) {
        res.getStatusDate().add(parseCitationStatusDateComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("relatedArtifact")) {
      JsonArray array = getJArray(json, "relatedArtifact");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedArtifact().add(parseRelatedArtifact(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("citedArtifact"))
      res.setCitedArtifact(parseCitationCitedArtifactComponent(getJObject(json, "citedArtifact")));
  }

  protected Citation.CitationSummaryComponent parseCitationSummaryComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationSummaryComponent res = new Citation.CitationSummaryComponent();
    parseCitationSummaryComponentProperties(json, res);
    return res;
  }

  protected void parseCitationSummaryComponentProperties(JsonObject json, Citation.CitationSummaryComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("style"))
      res.setStyle(parseCodeableConcept(getJObject(json, "style")));
    if (json.has("text"))
      res.setTextElement(parseMarkdown(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
  }

  protected Citation.CitationClassificationComponent parseCitationClassificationComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationClassificationComponent res = new Citation.CitationClassificationComponent();
    parseCitationClassificationComponentProperties(json, res);
    return res;
  }

  protected void parseCitationClassificationComponentProperties(JsonObject json, Citation.CitationClassificationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Citation.CitationStatusDateComponent parseCitationStatusDateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationStatusDateComponent res = new Citation.CitationStatusDateComponent();
    parseCitationStatusDateComponentProperties(json, res);
    return res;
  }

  protected void parseCitationStatusDateComponentProperties(JsonObject json, Citation.CitationStatusDateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("activity"))
      res.setActivity(parseCodeableConcept(getJObject(json, "activity")));
    if (json.has("actual"))
      res.setActualElement(parseBoolean(json.get("actual").getAsBoolean()));
    if (json.has("_actual"))
      parseElementProperties(getJObject(json, "_actual"), res.getActualElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Citation.CitationCitedArtifactComponent parseCitationCitedArtifactComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactComponent res = new Citation.CitationCitedArtifactComponent();
    parseCitationCitedArtifactComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactComponentProperties(JsonObject json, Citation.CitationCitedArtifactComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("relatedIdentifier")) {
      JsonArray array = getJArray(json, "relatedIdentifier");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("dateAccessed"))
      res.setDateAccessedElement(parseDateTime(json.get("dateAccessed").getAsString()));
    if (json.has("_dateAccessed"))
      parseElementProperties(getJObject(json, "_dateAccessed"), res.getDateAccessedElement());
    if (json.has("version"))
      res.setVersion(parseCitationCitedArtifactVersionComponent(getJObject(json, "version")));
    if (json.has("currentState")) {
      JsonArray array = getJArray(json, "currentState");
      for (int i = 0; i < array.size(); i++) {
        res.getCurrentState().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("statusDate")) {
      JsonArray array = getJArray(json, "statusDate");
      for (int i = 0; i < array.size(); i++) {
        res.getStatusDate().add(parseCitationCitedArtifactStatusDateComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("title")) {
      JsonArray array = getJArray(json, "title");
      for (int i = 0; i < array.size(); i++) {
        res.getTitle().add(parseCitationCitedArtifactTitleComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("abstract")) {
      JsonArray array = getJArray(json, "abstract");
      for (int i = 0; i < array.size(); i++) {
        res.getAbstract().add(parseCitationCitedArtifactAbstractComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("part"))
      res.setPart(parseCitationCitedArtifactPartComponent(getJObject(json, "part")));
    if (json.has("relatesTo")) {
      JsonArray array = getJArray(json, "relatesTo");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatesTo().add(parseCitationCitedArtifactRelatesToComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("publicationForm")) {
      JsonArray array = getJArray(json, "publicationForm");
      for (int i = 0; i < array.size(); i++) {
        res.getPublicationForm().add(parseCitationCitedArtifactPublicationFormComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("webLocation")) {
      JsonArray array = getJArray(json, "webLocation");
      for (int i = 0; i < array.size(); i++) {
        res.getWebLocation().add(parseCitationCitedArtifactWebLocationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("classification")) {
      JsonArray array = getJArray(json, "classification");
      for (int i = 0; i < array.size(); i++) {
        res.getClassification().add(parseCitationCitedArtifactClassificationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("contributorship"))
      res.setContributorship(parseCitationCitedArtifactContributorshipComponent(getJObject(json, "contributorship")));
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Citation.CitationCitedArtifactVersionComponent parseCitationCitedArtifactVersionComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactVersionComponent res = new Citation.CitationCitedArtifactVersionComponent();
    parseCitationCitedArtifactVersionComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactVersionComponentProperties(JsonObject json, Citation.CitationCitedArtifactVersionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
    if (json.has("baseCitation"))
      res.setBaseCitation(parseReference(getJObject(json, "baseCitation")));
  }

  protected Citation.CitationCitedArtifactStatusDateComponent parseCitationCitedArtifactStatusDateComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactStatusDateComponent res = new Citation.CitationCitedArtifactStatusDateComponent();
    parseCitationCitedArtifactStatusDateComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactStatusDateComponentProperties(JsonObject json, Citation.CitationCitedArtifactStatusDateComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("activity"))
      res.setActivity(parseCodeableConcept(getJObject(json, "activity")));
    if (json.has("actual"))
      res.setActualElement(parseBoolean(json.get("actual").getAsBoolean()));
    if (json.has("_actual"))
      parseElementProperties(getJObject(json, "_actual"), res.getActualElement());
    if (json.has("period"))
      res.setPeriod(parsePeriod(getJObject(json, "period")));
  }

  protected Citation.CitationCitedArtifactTitleComponent parseCitationCitedArtifactTitleComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactTitleComponent res = new Citation.CitationCitedArtifactTitleComponent();
    parseCitationCitedArtifactTitleComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactTitleComponentProperties(JsonObject json, Citation.CitationCitedArtifactTitleComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("language"))
      res.setLanguage(parseCodeableConcept(getJObject(json, "language")));
    if (json.has("text"))
      res.setTextElement(parseMarkdown(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
  }

  protected Citation.CitationCitedArtifactAbstractComponent parseCitationCitedArtifactAbstractComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactAbstractComponent res = new Citation.CitationCitedArtifactAbstractComponent();
    parseCitationCitedArtifactAbstractComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactAbstractComponentProperties(JsonObject json, Citation.CitationCitedArtifactAbstractComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("language"))
      res.setLanguage(parseCodeableConcept(getJObject(json, "language")));
    if (json.has("text"))
      res.setTextElement(parseMarkdown(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
  }

  protected Citation.CitationCitedArtifactPartComponent parseCitationCitedArtifactPartComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactPartComponent res = new Citation.CitationCitedArtifactPartComponent();
    parseCitationCitedArtifactPartComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactPartComponentProperties(JsonObject json, Citation.CitationCitedArtifactPartComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
    if (json.has("baseCitation"))
      res.setBaseCitation(parseReference(getJObject(json, "baseCitation")));
  }

  protected Citation.CitationCitedArtifactRelatesToComponent parseCitationCitedArtifactRelatesToComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactRelatesToComponent res = new Citation.CitationCitedArtifactRelatesToComponent();
    parseCitationCitedArtifactRelatesToComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactRelatesToComponentProperties(JsonObject json, Citation.CitationCitedArtifactRelatesToComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Citation.RelatedArtifactTypeExpanded.NULL, new Citation.RelatedArtifactTypeExpandedEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("label"))
      res.setLabelElement(parseString(json.get("label").getAsString()));
    if (json.has("_label"))
      parseElementProperties(getJObject(json, "_label"), res.getLabelElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(getJObject(json, "_display"), res.getDisplayElement());
    if (json.has("citation"))
      res.setCitationElement(parseMarkdown(json.get("citation").getAsString()));
    if (json.has("_citation"))
      parseElementProperties(getJObject(json, "_citation"), res.getCitationElement());
    if (json.has("document"))
      res.setDocument(parseAttachment(getJObject(json, "document")));
    if (json.has("resource"))
      res.setResourceElement(parseCanonical(json.get("resource").getAsString()));
    if (json.has("_resource"))
      parseElementProperties(getJObject(json, "_resource"), res.getResourceElement());
    if (json.has("resourceReference"))
      res.setResourceReference(parseReference(getJObject(json, "resourceReference")));
  }

  protected Citation.CitationCitedArtifactPublicationFormComponent parseCitationCitedArtifactPublicationFormComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactPublicationFormComponent res = new Citation.CitationCitedArtifactPublicationFormComponent();
    parseCitationCitedArtifactPublicationFormComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactPublicationFormComponentProperties(JsonObject json, Citation.CitationCitedArtifactPublicationFormComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("publishedIn"))
      res.setPublishedIn(parseCitationCitedArtifactPublicationFormPublishedInComponent(getJObject(json, "publishedIn")));
    if (json.has("citedMedium"))
      res.setCitedMedium(parseCodeableConcept(getJObject(json, "citedMedium")));
    if (json.has("volume"))
      res.setVolumeElement(parseString(json.get("volume").getAsString()));
    if (json.has("_volume"))
      parseElementProperties(getJObject(json, "_volume"), res.getVolumeElement());
    if (json.has("issue"))
      res.setIssueElement(parseString(json.get("issue").getAsString()));
    if (json.has("_issue"))
      parseElementProperties(getJObject(json, "_issue"), res.getIssueElement());
    if (json.has("publicationDateYear"))
      res.setPublicationDateYearElement(parseString(json.get("publicationDateYear").getAsString()));
    if (json.has("_publicationDateYear"))
      parseElementProperties(getJObject(json, "_publicationDateYear"), res.getPublicationDateYearElement());
    if (json.has("publicationDateMonth"))
      res.setPublicationDateMonthElement(parseString(json.get("publicationDateMonth").getAsString()));
    if (json.has("_publicationDateMonth"))
      parseElementProperties(getJObject(json, "_publicationDateMonth"), res.getPublicationDateMonthElement());
    if (json.has("publicationDateDay"))
      res.setPublicationDateDayElement(parseString(json.get("publicationDateDay").getAsString()));
    if (json.has("_publicationDateDay"))
      parseElementProperties(getJObject(json, "_publicationDateDay"), res.getPublicationDateDayElement());
    if (json.has("publicationDateSeason"))
      res.setPublicationDateSeasonElement(parseString(json.get("publicationDateSeason").getAsString()));
    if (json.has("_publicationDateSeason"))
      parseElementProperties(getJObject(json, "_publicationDateSeason"), res.getPublicationDateSeasonElement());
    if (json.has("publicationDateText"))
      res.setPublicationDateTextElement(parseString(json.get("publicationDateText").getAsString()));
    if (json.has("_publicationDateText"))
      parseElementProperties(getJObject(json, "_publicationDateText"), res.getPublicationDateTextElement());
    if (json.has("articleDate"))
      res.setArticleDateElement(parseDateTime(json.get("articleDate").getAsString()));
    if (json.has("_articleDate"))
      parseElementProperties(getJObject(json, "_articleDate"), res.getArticleDateElement());
    if (json.has("lastRevisionDate"))
      res.setLastRevisionDateElement(parseDateTime(json.get("lastRevisionDate").getAsString()));
    if (json.has("_lastRevisionDate"))
      parseElementProperties(getJObject(json, "_lastRevisionDate"), res.getLastRevisionDateElement());
    if (json.has("language")) {
      JsonArray array = getJArray(json, "language");
      for (int i = 0; i < array.size(); i++) {
        res.getLanguage().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("accessionNumber"))
      res.setAccessionNumberElement(parseString(json.get("accessionNumber").getAsString()));
    if (json.has("_accessionNumber"))
      parseElementProperties(getJObject(json, "_accessionNumber"), res.getAccessionNumberElement());
    if (json.has("pageString"))
      res.setPageStringElement(parseString(json.get("pageString").getAsString()));
    if (json.has("_pageString"))
      parseElementProperties(getJObject(json, "_pageString"), res.getPageStringElement());
    if (json.has("firstPage"))
      res.setFirstPageElement(parseString(json.get("firstPage").getAsString()));
    if (json.has("_firstPage"))
      parseElementProperties(getJObject(json, "_firstPage"), res.getFirstPageElement());
    if (json.has("lastPage"))
      res.setLastPageElement(parseString(json.get("lastPage").getAsString()));
    if (json.has("_lastPage"))
      parseElementProperties(getJObject(json, "_lastPage"), res.getLastPageElement());
    if (json.has("pageCount"))
      res.setPageCountElement(parseString(json.get("pageCount").getAsString()));
    if (json.has("_pageCount"))
      parseElementProperties(getJObject(json, "_pageCount"), res.getPageCountElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
  }

  protected Citation.CitationCitedArtifactPublicationFormPublishedInComponent parseCitationCitedArtifactPublicationFormPublishedInComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactPublicationFormPublishedInComponent res = new Citation.CitationCitedArtifactPublicationFormPublishedInComponent();
    parseCitationCitedArtifactPublicationFormPublishedInComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactPublicationFormPublishedInComponentProperties(JsonObject json, Citation.CitationCitedArtifactPublicationFormPublishedInComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("publisher"))
      res.setPublisher(parseReference(getJObject(json, "publisher")));
    if (json.has("publisherLocation"))
      res.setPublisherLocationElement(parseString(json.get("publisherLocation").getAsString()));
    if (json.has("_publisherLocation"))
      parseElementProperties(getJObject(json, "_publisherLocation"), res.getPublisherLocationElement());
  }

  protected Citation.CitationCitedArtifactWebLocationComponent parseCitationCitedArtifactWebLocationComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactWebLocationComponent res = new Citation.CitationCitedArtifactWebLocationComponent();
    parseCitationCitedArtifactWebLocationComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactWebLocationComponentProperties(JsonObject json, Citation.CitationCitedArtifactWebLocationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
  }

  protected Citation.CitationCitedArtifactClassificationComponent parseCitationCitedArtifactClassificationComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactClassificationComponent res = new Citation.CitationCitedArtifactClassificationComponent();
    parseCitationCitedArtifactClassificationComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactClassificationComponentProperties(JsonObject json, Citation.CitationCitedArtifactClassificationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("classifier")) {
      JsonArray array = getJArray(json, "classifier");
      for (int i = 0; i < array.size(); i++) {
        res.getClassifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("artifactAssessment")) {
      JsonArray array = getJArray(json, "artifactAssessment");
      for (int i = 0; i < array.size(); i++) {
        res.getArtifactAssessment().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Citation.CitationCitedArtifactContributorshipComponent parseCitationCitedArtifactContributorshipComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactContributorshipComponent res = new Citation.CitationCitedArtifactContributorshipComponent();
    parseCitationCitedArtifactContributorshipComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactContributorshipComponentProperties(JsonObject json, Citation.CitationCitedArtifactContributorshipComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("complete"))
      res.setCompleteElement(parseBoolean(json.get("complete").getAsBoolean()));
    if (json.has("_complete"))
      parseElementProperties(getJObject(json, "_complete"), res.getCompleteElement());
    if (json.has("entry")) {
      JsonArray array = getJArray(json, "entry");
      for (int i = 0; i < array.size(); i++) {
        res.getEntry().add(parseCitationCitedArtifactContributorshipEntryComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("summary")) {
      JsonArray array = getJArray(json, "summary");
      for (int i = 0; i < array.size(); i++) {
        res.getSummary().add(parseCitationContributorshipSummaryComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Citation.CitationCitedArtifactContributorshipEntryComponent parseCitationCitedArtifactContributorshipEntryComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactContributorshipEntryComponent res = new Citation.CitationCitedArtifactContributorshipEntryComponent();
    parseCitationCitedArtifactContributorshipEntryComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactContributorshipEntryComponentProperties(JsonObject json, Citation.CitationCitedArtifactContributorshipEntryComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("contributor"))
      res.setContributor(parseReference(getJObject(json, "contributor")));
    if (json.has("forenameInitials"))
      res.setForenameInitialsElement(parseString(json.get("forenameInitials").getAsString()));
    if (json.has("_forenameInitials"))
      parseElementProperties(getJObject(json, "_forenameInitials"), res.getForenameInitialsElement());
    if (json.has("affiliation")) {
      JsonArray array = getJArray(json, "affiliation");
      for (int i = 0; i < array.size(); i++) {
        res.getAffiliation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("contributionType")) {
      JsonArray array = getJArray(json, "contributionType");
      for (int i = 0; i < array.size(); i++) {
        res.getContributionType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("role"))
      res.setRole(parseCodeableConcept(getJObject(json, "role")));
    if (json.has("contributionInstance")) {
      JsonArray array = getJArray(json, "contributionInstance");
      for (int i = 0; i < array.size(); i++) {
        res.getContributionInstance().add(parseCitationCitedArtifactContributorshipEntryContributionInstanceComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("correspondingContact"))
      res.setCorrespondingContactElement(parseBoolean(json.get("correspondingContact").getAsBoolean()));
    if (json.has("_correspondingContact"))
      parseElementProperties(getJObject(json, "_correspondingContact"), res.getCorrespondingContactElement());
    if (json.has("rankingOrder"))
      res.setRankingOrderElement(parsePositiveInt(json.get("rankingOrder").getAsString()));
    if (json.has("_rankingOrder"))
      parseElementProperties(getJObject(json, "_rankingOrder"), res.getRankingOrderElement());
  }

  protected Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent parseCitationCitedArtifactContributorshipEntryContributionInstanceComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent res = new Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent();
    parseCitationCitedArtifactContributorshipEntryContributionInstanceComponentProperties(json, res);
    return res;
  }

  protected void parseCitationCitedArtifactContributorshipEntryContributionInstanceComponentProperties(JsonObject json, Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("time"))
      res.setTimeElement(parseDateTime(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(getJObject(json, "_time"), res.getTimeElement());
  }

  protected Citation.ContributorshipSummaryComponent parseCitationContributorshipSummaryComponent(JsonObject json) throws IOException, FHIRFormatError {
    Citation.ContributorshipSummaryComponent res = new Citation.ContributorshipSummaryComponent();
    parseCitationContributorshipSummaryComponentProperties(json, res);
    return res;
  }

  protected void parseCitationContributorshipSummaryComponentProperties(JsonObject json, Citation.ContributorshipSummaryComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("style"))
      res.setStyle(parseCodeableConcept(getJObject(json, "style")));
    if (json.has("source"))
      res.setSource(parseCodeableConcept(getJObject(json, "source")));
    if (json.has("value"))
      res.setValueElement(parseMarkdown(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
  }

  protected Claim parseClaim(JsonObject json) throws IOException, FHIRFormatError {
    Claim res = new Claim();
    parseClaimProperties(json, res);
    return res;
  }

  protected void parseClaimProperties(JsonObject json, Claim res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), Enumerations.FinancialResourceStatusCodes.NULL, new Enumerations.FinancialResourceStatusCodesEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("subType"))
      res.setSubType(parseCodeableConcept(getJObject(json, "subType")));
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Enumerations.Use.NULL, new Enumerations.UseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(getJObject(json, "_use"), res.getUseElement());
    if (json.has("patient"))
      res.setPatient(parseReference(getJObject(json, "patient")));
    if (json.has("billablePeriod"))
      res.setBillablePeriod(parsePeriod(getJObject(json, "billablePeriod")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(getJObject(json, "_created"), res.getCreatedElement());
    if (json.has("enterer"))
      res.setEnterer(parseReference(getJObject(json, "enterer")));
    if (json.has("insurer"))
      res.setInsurer(parseReference(getJObject(json, "insurer")));
    if (json.has("provider"))
      res.setProvider(parseReference(getJObject(json, "provider")));
    if (json.has("priority"))
      res.setPriority(parseCodeableConcept(getJObject(json, "priority")));
    if (json.has("fundsReserve"))
      res.setFundsReserve(parseCodeableConcept(getJObject(json, "fundsReserve")));
    if (json.has("related")) {
      JsonArray array = getJArray(json, "related");
      for (int i = 0; i < array.size(); i++) {
        res.getRelated().add(parseClaimRelatedClaimComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("prescription"))
      res.setPrescription(parseReference(getJObject(json, "prescription")));
    if (json.has("originalPrescription"))
      res.setOriginalPrescription(parseReference(getJObject(json, "originalPrescription")));
    if (json.has("payee"))
      res.setPayee(parseClaimPayeeComponent(getJObject(json, "payee")));
    if (json.has("referral"))
      res.setReferral(parseReference(getJObject(json, "referral")));
    if (json.has("encounter")) {
      JsonArray array = getJArray(json, "encounter");
      for (int i = 0; i < array.size(); i++) {
        res.getEncounter().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("facility"))
      res.setFacility(parseReference(getJObject(json, "facility")));
    if (json.has("diagnosisRelatedGroup"))
      res.setDiagnosisRelatedGroup(parseCodeableConcept(getJObject(json, "diagnosisRelatedGroup")));
    if (json.has("careTeam")) {
      JsonArray array = getJArray(json, "careTeam");
      for (int i = 0; i < array.size(); i++) {
        res.getCareTeam().add(parseClaimCareTeamComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInfo")) {
      JsonArray array = getJArray(json, "supportingInfo");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInfo().add(parseClaimSupportingInformationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("diagnosis")) {
      JsonArray array = getJArray(json, "diagnosis");
      for (int i = 0; i < array.size(); i++) {
        res.getDiagnosis().add(parseClaimDiagnosisComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("procedure")) {
      JsonArray array = getJArray(json, "procedure");
      for (int i = 0; i < array.size(); i++) {
        res.getProcedure().add(parseClaimProcedureComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("insurance")) {
      JsonArray array = getJArray(json, "insurance");
      for (int i = 0; i < array.size(); i++) {
        res.getInsurance().add(parseClaimInsuranceComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("accident"))
      res.setAccident(parseClaimAccidentComponent(getJObject(json, "accident")));
    if (json.has("patientPaid"))
      res.setPatientPaid(parseMoney(getJObject(json, "patientPaid")));
    if (json.has("item")) {
      JsonArray array = getJArray(json, "item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseClaimItemComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("total"))
      res.setTotal(parseMoney(getJObject(json, "total")));
  }

  protected Claim.RelatedClaimComponent parseClaimRelatedClaimComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.RelatedClaimComponent res = new Claim.RelatedClaimComponent();
    parseClaimRelatedClaimComponentProperties(json, res);
    return res;
  }

  protected void parseClaimRelatedClaimComponentProperties(JsonObject json, Claim.RelatedClaimComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("claim"))
      res.setClaim(parseReference(getJObject(json, "claim")));
    if (json.has("relationship"))
      res.setRelationship(parseCodeableConcept(getJObject(json, "relationship")));
    if (json.has("reference"))
      res.setReference(parseIdentifier(getJObject(json, "reference")));
  }

  protected Claim.PayeeComponent parseClaimPayeeComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.PayeeComponent res = new Claim.PayeeComponent();
    parseClaimPayeeComponentProperties(json, res);
    return res;
  }

  protected void parseClaimPayeeComponentProperties(JsonObject json, Claim.PayeeComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("party"))
      res.setParty(parseReference(getJObject(json, "party")));
  }

  protected Claim.CareTeamComponent parseClaimCareTeamComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.CareTeamComponent res = new Claim.CareTeamComponent();
    parseClaimCareTeamComponentProperties(json, res);
    return res;
  }

  protected void parseClaimCareTeamComponentProperties(JsonObject json, Claim.CareTeamComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("provider"))
      res.setProvider(parseReference(getJObject(json, "provider")));
    if (json.has("responsible"))
      res.setResponsibleElement(parseBoolean(json.get("responsible").getAsBoolean()));
    if (json.has("_responsible"))
      parseElementProperties(getJObject(json, "_responsible"), res.getResponsibleElement());
    if (json.has("role"))
      res.setRole(parseCodeableConcept(getJObject(json, "role")));
    if (json.has("specialty"))
      res.setSpecialty(parseCodeableConcept(getJObject(json, "specialty")));
  }

  protected Claim.SupportingInformationComponent parseClaimSupportingInformationComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.SupportingInformationComponent res = new Claim.SupportingInformationComponent();
    parseClaimSupportingInformationComponentProperties(json, res);
    return res;
  }

  protected void parseClaimSupportingInformationComponentProperties(JsonObject json, Claim.SupportingInformationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
    DataType timing = parseType("timing", json);
    if (timing != null)
      res.setTiming(timing);
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(getJObject(json, "reason")));
  }

  protected Claim.DiagnosisComponent parseClaimDiagnosisComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.DiagnosisComponent res = new Claim.DiagnosisComponent();
    parseClaimDiagnosisComponentProperties(json, res);
    return res;
  }

  protected void parseClaimDiagnosisComponentProperties(JsonObject json, Claim.DiagnosisComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    DataType diagnosis = parseType("diagnosis", json);
    if (diagnosis != null)
      res.setDiagnosis(diagnosis);
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("onAdmission"))
      res.setOnAdmission(parseCodeableConcept(getJObject(json, "onAdmission")));
  }

  protected Claim.ProcedureComponent parseClaimProcedureComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.ProcedureComponent res = new Claim.ProcedureComponent();
    parseClaimProcedureComponentProperties(json, res);
    return res;
  }

  protected void parseClaimProcedureComponentProperties(JsonObject json, Claim.ProcedureComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("type")) {
      JsonArray array = getJArray(json, "type");
      for (int i = 0; i < array.size(); i++) {
        res.getType().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    DataType procedure = parseType("procedure", json);
    if (procedure != null)
      res.setProcedure(procedure);
    if (json.has("udi")) {
      JsonArray array = getJArray(json, "udi");
      for (int i = 0; i < array.size(); i++) {
        res.getUdi().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Claim.InsuranceComponent parseClaimInsuranceComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.InsuranceComponent res = new Claim.InsuranceComponent();
    parseClaimInsuranceComponentProperties(json, res);
    return res;
  }

  protected void parseClaimInsuranceComponentProperties(JsonObject json, Claim.InsuranceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("focal"))
      res.setFocalElement(parseBoolean(json.get("focal").getAsBoolean()));
    if (json.has("_focal"))
      parseElementProperties(getJObject(json, "_focal"), res.getFocalElement());
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(getJObject(json, "identifier")));
    if (json.has("coverage"))
      res.setCoverage(parseReference(getJObject(json, "coverage")));
    if (json.has("businessArrangement"))
      res.setBusinessArrangementElement(parseString(json.get("businessArrangement").getAsString()));
    if (json.has("_businessArrangement"))
      parseElementProperties(getJObject(json, "_businessArrangement"), res.getBusinessArrangementElement());
    if (json.has("preAuthRef")) {
      JsonArray array = getJArray(json, "preAuthRef");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getPreAuthRef().add(new StringType());
        } else {;
          res.getPreAuthRef().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_preAuthRef")) {
      JsonArray array = getJArray(json, "_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(getJObject(json, "claimResponse")));
  }

  protected Claim.AccidentComponent parseClaimAccidentComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.AccidentComponent res = new Claim.AccidentComponent();
    parseClaimAccidentComponentProperties(json, res);
    return res;
  }

  protected void parseClaimAccidentComponentProperties(JsonObject json, Claim.AccidentComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("date"))
      res.setDateElement(parseDate(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    DataType location = parseType("location", json);
    if (location != null)
      res.setLocation(location);
  }

  protected Claim.ItemComponent parseClaimItemComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.ItemComponent res = new Claim.ItemComponent();
    parseClaimItemComponentProperties(json, res);
    return res;
  }

  protected void parseClaimItemComponentProperties(JsonObject json, Claim.ItemComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("careTeamSequence")) {
      JsonArray array = getJArray(json, "careTeamSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getCareTeamSequence().add(new PositiveIntType());
        } else {;
          res.getCareTeamSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_careTeamSequence")) {
      JsonArray array = getJArray(json, "_careTeamSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getCareTeamSequence().size())
          res.getCareTeamSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getCareTeamSequence().get(i));
      }
    };
    if (json.has("diagnosisSequence")) {
      JsonArray array = getJArray(json, "diagnosisSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDiagnosisSequence().add(new PositiveIntType());
        } else {;
          res.getDiagnosisSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_diagnosisSequence")) {
      JsonArray array = getJArray(json, "_diagnosisSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDiagnosisSequence().size())
          res.getDiagnosisSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDiagnosisSequence().get(i));
      }
    };
    if (json.has("procedureSequence")) {
      JsonArray array = getJArray(json, "procedureSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getProcedureSequence().add(new PositiveIntType());
        } else {;
          res.getProcedureSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_procedureSequence")) {
      JsonArray array = getJArray(json, "_procedureSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProcedureSequence().size())
          res.getProcedureSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProcedureSequence().get(i));
      }
    };
    if (json.has("informationSequence")) {
      JsonArray array = getJArray(json, "informationSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInformationSequence().add(new PositiveIntType());
        } else {;
          res.getInformationSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_informationSequence")) {
      JsonArray array = getJArray(json, "_informationSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInformationSequence().size())
          res.getInformationSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInformationSequence().get(i));
      }
    };
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("programCode")) {
      JsonArray array = getJArray(json, "programCode");
      for (int i = 0; i < array.size(); i++) {
        res.getProgramCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    DataType serviced = parseType("serviced", json);
    if (serviced != null)
      res.setServiced(serviced);
    DataType location = parseType("location", json);
    if (location != null)
      res.setLocation(location);
    if (json.has("patientPaid"))
      res.setPatientPaid(parseMoney(getJObject(json, "patientPaid")));
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("udi")) {
      JsonArray array = getJArray(json, "udi");
      for (int i = 0; i < array.size(); i++) {
        res.getUdi().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("bodySite")) {
      JsonArray array = getJArray(json, "bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseClaimBodySiteComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("encounter")) {
      JsonArray array = getJArray(json, "encounter");
      for (int i = 0; i < array.size(); i++) {
        res.getEncounter().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("detail")) {
      JsonArray array = getJArray(json, "detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Claim.BodySiteComponent parseClaimBodySiteComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.BodySiteComponent res = new Claim.BodySiteComponent();
    parseClaimBodySiteComponentProperties(json, res);
    return res;
  }

  protected void parseClaimBodySiteComponentProperties(JsonObject json, Claim.BodySiteComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("site")) {
      JsonArray array = getJArray(json, "site");
      for (int i = 0; i < array.size(); i++) {
        res.getSite().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subSite")) {
      JsonArray array = getJArray(json, "subSite");
      for (int i = 0; i < array.size(); i++) {
        res.getSubSite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Claim.DetailComponent parseClaimDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.DetailComponent res = new Claim.DetailComponent();
    parseClaimDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimDetailComponentProperties(JsonObject json, Claim.DetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("programCode")) {
      JsonArray array = getJArray(json, "programCode");
      for (int i = 0; i < array.size(); i++) {
        res.getProgramCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patientPaid"))
      res.setPatientPaid(parseMoney(getJObject(json, "patientPaid")));
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("udi")) {
      JsonArray array = getJArray(json, "udi");
      for (int i = 0; i < array.size(); i++) {
        res.getUdi().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subDetail")) {
      JsonArray array = getJArray(json, "subDetail");
      for (int i = 0; i < array.size(); i++) {
        res.getSubDetail().add(parseClaimSubDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Claim.SubDetailComponent parseClaimSubDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    Claim.SubDetailComponent res = new Claim.SubDetailComponent();
    parseClaimSubDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimSubDetailComponentProperties(JsonObject json, Claim.SubDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("programCode")) {
      JsonArray array = getJArray(json, "programCode");
      for (int i = 0; i < array.size(); i++) {
        res.getProgramCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("patientPaid"))
      res.setPatientPaid(parseMoney(getJObject(json, "patientPaid")));
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("udi")) {
      JsonArray array = getJArray(json, "udi");
      for (int i = 0; i < array.size(); i++) {
        res.getUdi().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse parseClaimResponse(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse res = new ClaimResponse();
    parseClaimResponseProperties(json, res);
    return res;
  }

  protected void parseClaimResponseProperties(JsonObject json, ClaimResponse res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), Enumerations.FinancialResourceStatusCodes.NULL, new Enumerations.FinancialResourceStatusCodesEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("subType"))
      res.setSubType(parseCodeableConcept(getJObject(json, "subType")));
    if (json.has("use"))
      res.setUseElement(parseEnumeration(json.get("use").getAsString(), Enumerations.Use.NULL, new Enumerations.UseEnumFactory()));
    if (json.has("_use"))
      parseElementProperties(getJObject(json, "_use"), res.getUseElement());
    if (json.has("patient"))
      res.setPatient(parseReference(getJObject(json, "patient")));
    if (json.has("created"))
      res.setCreatedElement(parseDateTime(json.get("created").getAsString()));
    if (json.has("_created"))
      parseElementProperties(getJObject(json, "_created"), res.getCreatedElement());
    if (json.has("insurer"))
      res.setInsurer(parseReference(getJObject(json, "insurer")));
    if (json.has("requestor"))
      res.setRequestor(parseReference(getJObject(json, "requestor")));
    if (json.has("request"))
      res.setRequest(parseReference(getJObject(json, "request")));
    if (json.has("outcome"))
      res.setOutcomeElement(parseEnumeration(json.get("outcome").getAsString(), Enumerations.ClaimProcessingCodes.NULL, new Enumerations.ClaimProcessingCodesEnumFactory()));
    if (json.has("_outcome"))
      parseElementProperties(getJObject(json, "_outcome"), res.getOutcomeElement());
    if (json.has("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("disposition"))
      res.setDispositionElement(parseString(json.get("disposition").getAsString()));
    if (json.has("_disposition"))
      parseElementProperties(getJObject(json, "_disposition"), res.getDispositionElement());
    if (json.has("preAuthRef"))
      res.setPreAuthRefElement(parseString(json.get("preAuthRef").getAsString()));
    if (json.has("_preAuthRef"))
      parseElementProperties(getJObject(json, "_preAuthRef"), res.getPreAuthRefElement());
    if (json.has("preAuthPeriod"))
      res.setPreAuthPeriod(parsePeriod(getJObject(json, "preAuthPeriod")));
    if (json.has("payeeType"))
      res.setPayeeType(parseCodeableConcept(getJObject(json, "payeeType")));
    if (json.has("encounter")) {
      JsonArray array = getJArray(json, "encounter");
      for (int i = 0; i < array.size(); i++) {
        res.getEncounter().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("diagnosisRelatedGroup"))
      res.setDiagnosisRelatedGroup(parseCodeableConcept(getJObject(json, "diagnosisRelatedGroup")));
    if (json.has("item")) {
      JsonArray array = getJArray(json, "item");
      for (int i = 0; i < array.size(); i++) {
        res.getItem().add(parseClaimResponseItemComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("addItem")) {
      JsonArray array = getJArray(json, "addItem");
      for (int i = 0; i < array.size(); i++) {
        res.getAddItem().add(parseClaimResponseAddedItemComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("total")) {
      JsonArray array = getJArray(json, "total");
      for (int i = 0; i < array.size(); i++) {
        res.getTotal().add(parseClaimResponseTotalComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("payment"))
      res.setPayment(parseClaimResponsePaymentComponent(getJObject(json, "payment")));
    if (json.has("fundsReserve"))
      res.setFundsReserve(parseCodeableConcept(getJObject(json, "fundsReserve")));
    if (json.has("formCode"))
      res.setFormCode(parseCodeableConcept(getJObject(json, "formCode")));
    if (json.has("form"))
      res.setForm(parseAttachment(getJObject(json, "form")));
    if (json.has("processNote")) {
      JsonArray array = getJArray(json, "processNote");
      for (int i = 0; i < array.size(); i++) {
        res.getProcessNote().add(parseClaimResponseNoteComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("communicationRequest")) {
      JsonArray array = getJArray(json, "communicationRequest");
      for (int i = 0; i < array.size(); i++) {
        res.getCommunicationRequest().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("insurance")) {
      JsonArray array = getJArray(json, "insurance");
      for (int i = 0; i < array.size(); i++) {
        res.getInsurance().add(parseClaimResponseInsuranceComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("error")) {
      JsonArray array = getJArray(json, "error");
      for (int i = 0; i < array.size(); i++) {
        res.getError().add(parseClaimResponseErrorComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.ItemComponent parseClaimResponseItemComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.ItemComponent res = new ClaimResponse.ItemComponent();
    parseClaimResponseItemComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseItemComponentProperties(JsonObject json, ClaimResponse.ItemComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("itemSequence"))
      res.setItemSequenceElement(parsePositiveInt(json.get("itemSequence").getAsString()));
    if (json.has("_itemSequence"))
      parseElementProperties(getJObject(json, "_itemSequence"), res.getItemSequenceElement());
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("detail")) {
      JsonArray array = getJArray(json, "detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimResponseItemDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.AdjudicationComponent parseClaimResponseAdjudicationComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.AdjudicationComponent res = new ClaimResponse.AdjudicationComponent();
    parseClaimResponseAdjudicationComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseAdjudicationComponentProperties(JsonObject json, ClaimResponse.AdjudicationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("reason"))
      res.setReason(parseCodeableConcept(getJObject(json, "reason")));
    if (json.has("amount"))
      res.setAmount(parseMoney(getJObject(json, "amount")));
    if (json.has("value"))
      res.setValueElement(parseDecimal(json.get("value").getAsBigDecimal()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
  }

  protected ClaimResponse.ItemDetailComponent parseClaimResponseItemDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.ItemDetailComponent res = new ClaimResponse.ItemDetailComponent();
    parseClaimResponseItemDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseItemDetailComponentProperties(JsonObject json, ClaimResponse.ItemDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("detailSequence"))
      res.setDetailSequenceElement(parsePositiveInt(json.get("detailSequence").getAsString()));
    if (json.has("_detailSequence"))
      parseElementProperties(getJObject(json, "_detailSequence"), res.getDetailSequenceElement());
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subDetail")) {
      JsonArray array = getJArray(json, "subDetail");
      for (int i = 0; i < array.size(); i++) {
        res.getSubDetail().add(parseClaimResponseSubDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.SubDetailComponent parseClaimResponseSubDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.SubDetailComponent res = new ClaimResponse.SubDetailComponent();
    parseClaimResponseSubDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseSubDetailComponentProperties(JsonObject json, ClaimResponse.SubDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("subDetailSequence"))
      res.setSubDetailSequenceElement(parsePositiveInt(json.get("subDetailSequence").getAsString()));
    if (json.has("_subDetailSequence"))
      parseElementProperties(getJObject(json, "_subDetailSequence"), res.getSubDetailSequenceElement());
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.AddedItemComponent parseClaimResponseAddedItemComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemComponent res = new ClaimResponse.AddedItemComponent();
    parseClaimResponseAddedItemComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseAddedItemComponentProperties(JsonObject json, ClaimResponse.AddedItemComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("itemSequence")) {
      JsonArray array = getJArray(json, "itemSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getItemSequence().add(new PositiveIntType());
        } else {;
          res.getItemSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_itemSequence")) {
      JsonArray array = getJArray(json, "_itemSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getItemSequence().size())
          res.getItemSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getItemSequence().get(i));
      }
    };
    if (json.has("detailSequence")) {
      JsonArray array = getJArray(json, "detailSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getDetailSequence().add(new PositiveIntType());
        } else {;
          res.getDetailSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_detailSequence")) {
      JsonArray array = getJArray(json, "_detailSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getDetailSequence().size())
          res.getDetailSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getDetailSequence().get(i));
      }
    };
    if (json.has("subdetailSequence")) {
      JsonArray array = getJArray(json, "subdetailSequence");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getSubdetailSequence().add(new PositiveIntType());
        } else {;
          res.getSubdetailSequence().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_subdetailSequence")) {
      JsonArray array = getJArray(json, "_subdetailSequence");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getSubdetailSequence().size())
          res.getSubdetailSequence().add(parsePositiveInt(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getSubdetailSequence().get(i));
      }
    };
    if (json.has("provider")) {
      JsonArray array = getJArray(json, "provider");
      for (int i = 0; i < array.size(); i++) {
        res.getProvider().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("programCode")) {
      JsonArray array = getJArray(json, "programCode");
      for (int i = 0; i < array.size(); i++) {
        res.getProgramCode().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    DataType serviced = parseType("serviced", json);
    if (serviced != null)
      res.setServiced(serviced);
    DataType location = parseType("location", json);
    if (location != null)
      res.setLocation(location);
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("bodySite")) {
      JsonArray array = getJArray(json, "bodySite");
      for (int i = 0; i < array.size(); i++) {
        res.getBodySite().add(parseClaimResponseBodySiteComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("detail")) {
      JsonArray array = getJArray(json, "detail");
      for (int i = 0; i < array.size(); i++) {
        res.getDetail().add(parseClaimResponseAddedItemDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.BodySiteComponent parseClaimResponseBodySiteComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.BodySiteComponent res = new ClaimResponse.BodySiteComponent();
    parseClaimResponseBodySiteComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseBodySiteComponentProperties(JsonObject json, ClaimResponse.BodySiteComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("site")) {
      JsonArray array = getJArray(json, "site");
      for (int i = 0; i < array.size(); i++) {
        res.getSite().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subSite")) {
      JsonArray array = getJArray(json, "subSite");
      for (int i = 0; i < array.size(); i++) {
        res.getSubSite().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.AddedItemDetailComponent parseClaimResponseAddedItemDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemDetailComponent res = new ClaimResponse.AddedItemDetailComponent();
    parseClaimResponseAddedItemDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseAddedItemDetailComponentProperties(JsonObject json, ClaimResponse.AddedItemDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subDetail")) {
      JsonArray array = getJArray(json, "subDetail");
      for (int i = 0; i < array.size(); i++) {
        res.getSubDetail().add(parseClaimResponseAddedItemSubDetailComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.AddedItemSubDetailComponent parseClaimResponseAddedItemSubDetailComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.AddedItemSubDetailComponent res = new ClaimResponse.AddedItemSubDetailComponent();
    parseClaimResponseAddedItemSubDetailComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseAddedItemSubDetailComponentProperties(JsonObject json, ClaimResponse.AddedItemSubDetailComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("revenue"))
      res.setRevenue(parseCodeableConcept(getJObject(json, "revenue")));
    if (json.has("productOrService"))
      res.setProductOrService(parseCodeableConcept(getJObject(json, "productOrService")));
    if (json.has("productOrServiceEnd"))
      res.setProductOrServiceEnd(parseCodeableConcept(getJObject(json, "productOrServiceEnd")));
    if (json.has("modifier")) {
      JsonArray array = getJArray(json, "modifier");
      for (int i = 0; i < array.size(); i++) {
        res.getModifier().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("quantity"))
      res.setQuantity(parseQuantity(getJObject(json, "quantity")));
    if (json.has("unitPrice"))
      res.setUnitPrice(parseMoney(getJObject(json, "unitPrice")));
    if (json.has("factor"))
      res.setFactorElement(parseDecimal(json.get("factor").getAsBigDecimal()));
    if (json.has("_factor"))
      parseElementProperties(getJObject(json, "_factor"), res.getFactorElement());
    if (json.has("tax"))
      res.setTax(parseMoney(getJObject(json, "tax")));
    if (json.has("net"))
      res.setNet(parseMoney(getJObject(json, "net")));
    if (json.has("noteNumber")) {
      JsonArray array = getJArray(json, "noteNumber");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getNoteNumber().add(new PositiveIntType());
        } else {;
          res.getNoteNumber().add(parsePositiveInt(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_noteNumber")) {
      JsonArray array = getJArray(json, "_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("decision"))
      res.setDecision(parseCodeableConcept(getJObject(json, "decision")));
    if (json.has("adjudication")) {
      JsonArray array = getJArray(json, "adjudication");
      for (int i = 0; i < array.size(); i++) {
        res.getAdjudication().add(parseClaimResponseAdjudicationComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClaimResponse.TotalComponent parseClaimResponseTotalComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.TotalComponent res = new ClaimResponse.TotalComponent();
    parseClaimResponseTotalComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseTotalComponentProperties(JsonObject json, ClaimResponse.TotalComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("category"))
      res.setCategory(parseCodeableConcept(getJObject(json, "category")));
    if (json.has("amount"))
      res.setAmount(parseMoney(getJObject(json, "amount")));
  }

  protected ClaimResponse.PaymentComponent parseClaimResponsePaymentComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.PaymentComponent res = new ClaimResponse.PaymentComponent();
    parseClaimResponsePaymentComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponsePaymentComponentProperties(JsonObject json, ClaimResponse.PaymentComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("adjustment"))
      res.setAdjustment(parseMoney(getJObject(json, "adjustment")));
    if (json.has("adjustmentReason"))
      res.setAdjustmentReason(parseCodeableConcept(getJObject(json, "adjustmentReason")));
    if (json.has("date"))
      res.setDateElement(parseDate(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("amount"))
      res.setAmount(parseMoney(getJObject(json, "amount")));
    if (json.has("identifier"))
      res.setIdentifier(parseIdentifier(getJObject(json, "identifier")));
  }

  protected ClaimResponse.NoteComponent parseClaimResponseNoteComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.NoteComponent res = new ClaimResponse.NoteComponent();
    parseClaimResponseNoteComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseNoteComponentProperties(JsonObject json, ClaimResponse.NoteComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("number"))
      res.setNumberElement(parsePositiveInt(json.get("number").getAsString()));
    if (json.has("_number"))
      parseElementProperties(getJObject(json, "_number"), res.getNumberElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), Enumerations.NoteType.NULL, new Enumerations.NoteTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("text"))
      res.setTextElement(parseString(json.get("text").getAsString()));
    if (json.has("_text"))
      parseElementProperties(getJObject(json, "_text"), res.getTextElement());
    if (json.has("language"))
      res.setLanguage(parseCodeableConcept(getJObject(json, "language")));
  }

  protected ClaimResponse.InsuranceComponent parseClaimResponseInsuranceComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.InsuranceComponent res = new ClaimResponse.InsuranceComponent();
    parseClaimResponseInsuranceComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseInsuranceComponentProperties(JsonObject json, ClaimResponse.InsuranceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("sequence"))
      res.setSequenceElement(parsePositiveInt(json.get("sequence").getAsString()));
    if (json.has("_sequence"))
      parseElementProperties(getJObject(json, "_sequence"), res.getSequenceElement());
    if (json.has("focal"))
      res.setFocalElement(parseBoolean(json.get("focal").getAsBoolean()));
    if (json.has("_focal"))
      parseElementProperties(getJObject(json, "_focal"), res.getFocalElement());
    if (json.has("coverage"))
      res.setCoverage(parseReference(getJObject(json, "coverage")));
    if (json.has("businessArrangement"))
      res.setBusinessArrangementElement(parseString(json.get("businessArrangement").getAsString()));
    if (json.has("_businessArrangement"))
      parseElementProperties(getJObject(json, "_businessArrangement"), res.getBusinessArrangementElement());
    if (json.has("claimResponse"))
      res.setClaimResponse(parseReference(getJObject(json, "claimResponse")));
  }

  protected ClaimResponse.ErrorComponent parseClaimResponseErrorComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClaimResponse.ErrorComponent res = new ClaimResponse.ErrorComponent();
    parseClaimResponseErrorComponentProperties(json, res);
    return res;
  }

  protected void parseClaimResponseErrorComponentProperties(JsonObject json, ClaimResponse.ErrorComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("itemSequence"))
      res.setItemSequenceElement(parsePositiveInt(json.get("itemSequence").getAsString()));
    if (json.has("_itemSequence"))
      parseElementProperties(getJObject(json, "_itemSequence"), res.getItemSequenceElement());
    if (json.has("detailSequence"))
      res.setDetailSequenceElement(parsePositiveInt(json.get("detailSequence").getAsString()));
    if (json.has("_detailSequence"))
      parseElementProperties(getJObject(json, "_detailSequence"), res.getDetailSequenceElement());
    if (json.has("subDetailSequence"))
      res.setSubDetailSequenceElement(parsePositiveInt(json.get("subDetailSequence").getAsString()));
    if (json.has("_subDetailSequence"))
      parseElementProperties(getJObject(json, "_subDetailSequence"), res.getSubDetailSequenceElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
  }

  protected ClinicalImpression parseClinicalImpression(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalImpression res = new ClinicalImpression();
    parseClinicalImpressionProperties(json, res);
    return res;
  }

  protected void parseClinicalImpressionProperties(JsonObject json, ClinicalImpression res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), Enumerations.EventStatus.NULL, new Enumerations.EventStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(getJObject(json, "statusReason")));
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    DataType effective = parseType("effective", json);
    if (effective != null)
      res.setEffective(effective);
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("performer"))
      res.setPerformer(parseReference(getJObject(json, "performer")));
    if (json.has("previous"))
      res.setPrevious(parseReference(getJObject(json, "previous")));
    if (json.has("problem")) {
      JsonArray array = getJArray(json, "problem");
      for (int i = 0; i < array.size(); i++) {
        res.getProblem().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("changePattern"))
      res.setChangePattern(parseCodeableConcept(getJObject(json, "changePattern")));
    if (json.has("protocol")) {
      JsonArray array = getJArray(json, "protocol");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getProtocol().add(new UriType());
        } else {;
          res.getProtocol().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_protocol")) {
      JsonArray array = getJArray(json, "_protocol");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getProtocol().size())
          res.getProtocol().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getProtocol().get(i));
      }
    };
    if (json.has("summary"))
      res.setSummaryElement(parseString(json.get("summary").getAsString()));
    if (json.has("_summary"))
      parseElementProperties(getJObject(json, "_summary"), res.getSummaryElement());
    if (json.has("finding")) {
      JsonArray array = getJArray(json, "finding");
      for (int i = 0; i < array.size(); i++) {
        res.getFinding().add(parseClinicalImpressionFindingComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("prognosisCodeableConcept")) {
      JsonArray array = getJArray(json, "prognosisCodeableConcept");
      for (int i = 0; i < array.size(); i++) {
        res.getPrognosisCodeableConcept().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("prognosisReference")) {
      JsonArray array = getJArray(json, "prognosisReference");
      for (int i = 0; i < array.size(); i++) {
        res.getPrognosisReference().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("supportingInfo")) {
      JsonArray array = getJArray(json, "supportingInfo");
      for (int i = 0; i < array.size(); i++) {
        res.getSupportingInfo().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClinicalImpression.ClinicalImpressionFindingComponent parseClinicalImpressionFindingComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalImpression.ClinicalImpressionFindingComponent res = new ClinicalImpression.ClinicalImpressionFindingComponent();
    parseClinicalImpressionFindingComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalImpressionFindingComponentProperties(JsonObject json, ClinicalImpression.ClinicalImpressionFindingComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("item"))
      res.setItem(parseCodeableReference(getJObject(json, "item")));
    if (json.has("basis"))
      res.setBasisElement(parseString(json.get("basis").getAsString()));
    if (json.has("_basis"))
      parseElementProperties(getJObject(json, "_basis"), res.getBasisElement());
  }

  protected ClinicalUseDefinition parseClinicalUseDefinition(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition res = new ClinicalUseDefinition();
    parseClinicalUseDefinitionProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionProperties(JsonObject json, ClinicalUseDefinition res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(), ClinicalUseDefinition.ClinicalUseDefinitionType.NULL, new ClinicalUseDefinition.ClinicalUseDefinitionTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subject")) {
      JsonArray array = getJArray(json, "subject");
      for (int i = 0; i < array.size(); i++) {
        res.getSubject().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("status"))
      res.setStatus(parseCodeableConcept(getJObject(json, "status")));
    if (json.has("contraindication"))
      res.setContraindication(parseClinicalUseDefinitionContraindicationComponent(getJObject(json, "contraindication")));
    if (json.has("indication"))
      res.setIndication(parseClinicalUseDefinitionIndicationComponent(getJObject(json, "indication")));
    if (json.has("interaction"))
      res.setInteraction(parseClinicalUseDefinitionInteractionComponent(getJObject(json, "interaction")));
    if (json.has("population")) {
      JsonArray array = getJArray(json, "population");
      for (int i = 0; i < array.size(); i++) {
        res.getPopulation().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("undesirableEffect"))
      res.setUndesirableEffect(parseClinicalUseDefinitionUndesirableEffectComponent(getJObject(json, "undesirableEffect")));
    if (json.has("warning"))
      res.setWarning(parseClinicalUseDefinitionWarningComponent(getJObject(json, "warning")));
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent parseClinicalUseDefinitionContraindicationComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent();
    parseClinicalUseDefinitionContraindicationComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionContraindicationComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("diseaseSymptomProcedure"))
      res.setDiseaseSymptomProcedure(parseCodeableReference(getJObject(json, "diseaseSymptomProcedure")));
    if (json.has("diseaseStatus"))
      res.setDiseaseStatus(parseCodeableReference(getJObject(json, "diseaseStatus")));
    if (json.has("comorbidity")) {
      JsonArray array = getJArray(json, "comorbidity");
      for (int i = 0; i < array.size(); i++) {
        res.getComorbidity().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("indication")) {
      JsonArray array = getJArray(json, "indication");
      for (int i = 0; i < array.size(); i++) {
        res.getIndication().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("otherTherapy")) {
      JsonArray array = getJArray(json, "otherTherapy");
      for (int i = 0; i < array.size(); i++) {
        res.getOtherTherapy().add(parseClinicalUseDefinitionContraindicationOtherTherapyComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent parseClinicalUseDefinitionContraindicationOtherTherapyComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent();
    parseClinicalUseDefinitionContraindicationOtherTherapyComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionContraindicationOtherTherapyComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("relationshipType"))
      res.setRelationshipType(parseCodeableConcept(getJObject(json, "relationshipType")));
    if (json.has("treatment"))
      res.setTreatment(parseCodeableReference(getJObject(json, "treatment")));
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent parseClinicalUseDefinitionIndicationComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent();
    parseClinicalUseDefinitionIndicationComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionIndicationComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("diseaseSymptomProcedure"))
      res.setDiseaseSymptomProcedure(parseCodeableReference(getJObject(json, "diseaseSymptomProcedure")));
    if (json.has("diseaseStatus"))
      res.setDiseaseStatus(parseCodeableReference(getJObject(json, "diseaseStatus")));
    if (json.has("comorbidity")) {
      JsonArray array = getJArray(json, "comorbidity");
      for (int i = 0; i < array.size(); i++) {
        res.getComorbidity().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("intendedEffect"))
      res.setIntendedEffect(parseCodeableReference(getJObject(json, "intendedEffect")));
    DataType duration = parseType("duration", json);
    if (duration != null)
      res.setDuration(duration);
    if (json.has("undesirableEffect")) {
      JsonArray array = getJArray(json, "undesirableEffect");
      for (int i = 0; i < array.size(); i++) {
        res.getUndesirableEffect().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("otherTherapy")) {
      JsonArray array = getJArray(json, "otherTherapy");
      for (int i = 0; i < array.size(); i++) {
        res.getOtherTherapy().add(parseClinicalUseDefinitionContraindicationOtherTherapyComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent parseClinicalUseDefinitionInteractionComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent();
    parseClinicalUseDefinitionInteractionComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionInteractionComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("interactant")) {
      JsonArray array = getJArray(json, "interactant");
      for (int i = 0; i < array.size(); i++) {
        res.getInteractant().add(parseClinicalUseDefinitionInteractionInteractantComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("effect"))
      res.setEffect(parseCodeableReference(getJObject(json, "effect")));
    if (json.has("incidence"))
      res.setIncidence(parseCodeableConcept(getJObject(json, "incidence")));
    if (json.has("management")) {
      JsonArray array = getJArray(json, "management");
      for (int i = 0; i < array.size(); i++) {
        res.getManagement().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent parseClinicalUseDefinitionInteractionInteractantComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent();
    parseClinicalUseDefinitionInteractionInteractantComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionInteractionInteractantComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType item = parseType("item", json);
    if (item != null)
      res.setItem(item);
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent parseClinicalUseDefinitionUndesirableEffectComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent();
    parseClinicalUseDefinitionUndesirableEffectComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionUndesirableEffectComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("symptomConditionEffect"))
      res.setSymptomConditionEffect(parseCodeableReference(getJObject(json, "symptomConditionEffect")));
    if (json.has("classification"))
      res.setClassification(parseCodeableConcept(getJObject(json, "classification")));
    if (json.has("frequencyOfOccurrence"))
      res.setFrequencyOfOccurrence(parseCodeableConcept(getJObject(json, "frequencyOfOccurrence")));
  }

  protected ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent parseClinicalUseDefinitionWarningComponent(JsonObject json) throws IOException, FHIRFormatError {
    ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent res = new ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent();
    parseClinicalUseDefinitionWarningComponentProperties(json, res);
    return res;
  }

  protected void parseClinicalUseDefinitionWarningComponentProperties(JsonObject json, ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("code"))
      res.setCode(parseCodeableConcept(getJObject(json, "code")));
  }

  protected CodeSystem parseCodeSystem(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem res = new CodeSystem();
    parseCodeSystemProperties(json, res);
    return res;
  }

  protected void parseCodeSystemProperties(JsonObject json, CodeSystem res) throws IOException, FHIRFormatError {
    parseMetadataResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("jurisdiction")) {
      JsonArray array = getJArray(json, "jurisdiction");
      for (int i = 0; i < array.size(); i++) {
        res.getJurisdiction().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("copyright"))
      res.setCopyrightElement(parseMarkdown(json.get("copyright").getAsString()));
    if (json.has("_copyright"))
      parseElementProperties(getJObject(json, "_copyright"), res.getCopyrightElement());
    if (json.has("approvalDate"))
      res.setApprovalDateElement(parseDate(json.get("approvalDate").getAsString()));
    if (json.has("_approvalDate"))
      parseElementProperties(getJObject(json, "_approvalDate"), res.getApprovalDateElement());
    if (json.has("lastReviewDate"))
      res.setLastReviewDateElement(parseDate(json.get("lastReviewDate").getAsString()));
    if (json.has("_lastReviewDate"))
      parseElementProperties(getJObject(json, "_lastReviewDate"), res.getLastReviewDateElement());
    if (json.has("effectivePeriod"))
      res.setEffectivePeriod(parsePeriod(getJObject(json, "effectivePeriod")));
    if (json.has("topic")) {
      JsonArray array = getJArray(json, "topic");
      for (int i = 0; i < array.size(); i++) {
        res.getTopic().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("author")) {
      JsonArray array = getJArray(json, "author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("editor")) {
      JsonArray array = getJArray(json, "editor");
      for (int i = 0; i < array.size(); i++) {
        res.getEditor().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reviewer")) {
      JsonArray array = getJArray(json, "reviewer");
      for (int i = 0; i < array.size(); i++) {
        res.getReviewer().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("endorser")) {
      JsonArray array = getJArray(json, "endorser");
      for (int i = 0; i < array.size(); i++) {
        res.getEndorser().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("relatedArtifact")) {
      JsonArray array = getJArray(json, "relatedArtifact");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatedArtifact().add(parseRelatedArtifact(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("caseSensitive"))
      res.setCaseSensitiveElement(parseBoolean(json.get("caseSensitive").getAsBoolean()));
    if (json.has("_caseSensitive"))
      parseElementProperties(getJObject(json, "_caseSensitive"), res.getCaseSensitiveElement());
    if (json.has("valueSet"))
      res.setValueSetElement(parseCanonical(json.get("valueSet").getAsString()));
    if (json.has("_valueSet"))
      parseElementProperties(getJObject(json, "_valueSet"), res.getValueSetElement());
    if (json.has("hierarchyMeaning"))
      res.setHierarchyMeaningElement(parseEnumeration(json.get("hierarchyMeaning").getAsString(), CodeSystem.CodeSystemHierarchyMeaning.NULL, new CodeSystem.CodeSystemHierarchyMeaningEnumFactory()));
    if (json.has("_hierarchyMeaning"))
      parseElementProperties(getJObject(json, "_hierarchyMeaning"), res.getHierarchyMeaningElement());
    if (json.has("compositional"))
      res.setCompositionalElement(parseBoolean(json.get("compositional").getAsBoolean()));
    if (json.has("_compositional"))
      parseElementProperties(getJObject(json, "_compositional"), res.getCompositionalElement());
    if (json.has("versionNeeded"))
      res.setVersionNeededElement(parseBoolean(json.get("versionNeeded").getAsBoolean()));
    if (json.has("_versionNeeded"))
      parseElementProperties(getJObject(json, "_versionNeeded"), res.getVersionNeededElement());
    if (json.has("content"))
      res.setContentElement(parseEnumeration(json.get("content").getAsString(), CodeSystem.CodeSystemContentMode.NULL, new CodeSystem.CodeSystemContentModeEnumFactory()));
    if (json.has("_content"))
      parseElementProperties(getJObject(json, "_content"), res.getContentElement());
    if (json.has("supplements"))
      res.setSupplementsElement(parseCanonical(json.get("supplements").getAsString()));
    if (json.has("_supplements"))
      parseElementProperties(getJObject(json, "_supplements"), res.getSupplementsElement());
    if (json.has("count"))
      res.setCountElement(parseUnsignedInt(json.get("count").getAsString()));
    if (json.has("_count"))
      parseElementProperties(getJObject(json, "_count"), res.getCountElement());
    if (json.has("filter")) {
      JsonArray array = getJArray(json, "filter");
      for (int i = 0; i < array.size(); i++) {
        res.getFilter().add(parseCodeSystemFilterComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("property")) {
      JsonArray array = getJArray(json, "property");
      for (int i = 0; i < array.size(); i++) {
        res.getProperty().add(parseCodeSystemPropertyComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("concept")) {
      JsonArray array = getJArray(json, "concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseCodeSystemConceptDefinitionComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CodeSystem.CodeSystemFilterComponent parseCodeSystemFilterComponent(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem.CodeSystemFilterComponent res = new CodeSystem.CodeSystemFilterComponent();
    parseCodeSystemFilterComponentProperties(json, res);
    return res;
  }

  protected void parseCodeSystemFilterComponentProperties(JsonObject json, CodeSystem.CodeSystemFilterComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("operator")) {
      JsonArray array = getJArray(json, "operator");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getOperator().add(new Enumeration<Enumerations.FilterOperator>(new Enumerations.FilterOperatorEnumFactory(), Enumerations.FilterOperator.NULL));
        } else {;
          res.getOperator().add(parseEnumeration(array.get(i).getAsString(), Enumerations.FilterOperator.NULL, new Enumerations.FilterOperatorEnumFactory()));
        }
      }
    };
    if (json.has("_operator")) {
      JsonArray array = getJArray(json, "_operator");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getOperator().size())
          res.getOperator().add(parseEnumeration(null, Enumerations.FilterOperator.NULL, new Enumerations.FilterOperatorEnumFactory()));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getOperator().get(i));
      }
    };
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
  }

  protected CodeSystem.PropertyComponent parseCodeSystemPropertyComponent(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem.PropertyComponent res = new CodeSystem.PropertyComponent();
    parseCodeSystemPropertyComponentProperties(json, res);
    return res;
  }

  protected void parseCodeSystemPropertyComponentProperties(JsonObject json, CodeSystem.PropertyComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("uri"))
      res.setUriElement(parseUri(json.get("uri").getAsString()));
    if (json.has("_uri"))
      parseElementProperties(getJObject(json, "_uri"), res.getUriElement());
    if (json.has("description"))
      res.setDescriptionElement(parseString(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("type"))
      res.setTypeElement(parseEnumeration(json.get("type").getAsString(), CodeSystem.PropertyType.NULL, new CodeSystem.PropertyTypeEnumFactory()));
    if (json.has("_type"))
      parseElementProperties(getJObject(json, "_type"), res.getTypeElement());
  }

  protected CodeSystem.ConceptDefinitionComponent parseCodeSystemConceptDefinitionComponent(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem.ConceptDefinitionComponent res = new CodeSystem.ConceptDefinitionComponent();
    parseCodeSystemConceptDefinitionComponentProperties(json, res);
    return res;
  }

  protected void parseCodeSystemConceptDefinitionComponentProperties(JsonObject json, CodeSystem.ConceptDefinitionComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("display"))
      res.setDisplayElement(parseString(json.get("display").getAsString()));
    if (json.has("_display"))
      parseElementProperties(getJObject(json, "_display"), res.getDisplayElement());
    if (json.has("definition"))
      res.setDefinitionElement(parseString(json.get("definition").getAsString()));
    if (json.has("_definition"))
      parseElementProperties(getJObject(json, "_definition"), res.getDefinitionElement());
    if (json.has("designation")) {
      JsonArray array = getJArray(json, "designation");
      for (int i = 0; i < array.size(); i++) {
        res.getDesignation().add(parseCodeSystemConceptDefinitionDesignationComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("property")) {
      JsonArray array = getJArray(json, "property");
      for (int i = 0; i < array.size(); i++) {
        res.getProperty().add(parseCodeSystemConceptPropertyComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("concept")) {
      JsonArray array = getJArray(json, "concept");
      for (int i = 0; i < array.size(); i++) {
        res.getConcept().add(parseCodeSystemConceptDefinitionComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CodeSystem.ConceptDefinitionDesignationComponent parseCodeSystemConceptDefinitionDesignationComponent(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem.ConceptDefinitionDesignationComponent res = new CodeSystem.ConceptDefinitionDesignationComponent();
    parseCodeSystemConceptDefinitionDesignationComponentProperties(json, res);
    return res;
  }

  protected void parseCodeSystemConceptDefinitionDesignationComponentProperties(JsonObject json, CodeSystem.ConceptDefinitionDesignationComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("language"))
      res.setLanguageElement(parseCode(json.get("language").getAsString()));
    if (json.has("_language"))
      parseElementProperties(getJObject(json, "_language"), res.getLanguageElement());
    if (json.has("use"))
      res.setUse(parseCoding(getJObject(json, "use")));
    if (json.has("additionalUse")) {
      JsonArray array = getJArray(json, "additionalUse");
      for (int i = 0; i < array.size(); i++) {
        res.getAdditionalUse().add(parseCoding(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("value"))
      res.setValueElement(parseString(json.get("value").getAsString()));
    if (json.has("_value"))
      parseElementProperties(getJObject(json, "_value"), res.getValueElement());
  }

  protected CodeSystem.ConceptPropertyComponent parseCodeSystemConceptPropertyComponent(JsonObject json) throws IOException, FHIRFormatError {
    CodeSystem.ConceptPropertyComponent res = new CodeSystem.ConceptPropertyComponent();
    parseCodeSystemConceptPropertyComponentProperties(json, res);
    return res;
  }

  protected void parseCodeSystemConceptPropertyComponentProperties(JsonObject json, CodeSystem.ConceptPropertyComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    DataType value = parseType("value", json);
    if (value != null)
      res.setValue(value);
  }

  protected Communication parseCommunication(JsonObject json) throws IOException, FHIRFormatError {
    Communication res = new Communication();
    parseCommunicationProperties(json, res);
    return res;
  }

  protected void parseCommunicationProperties(JsonObject json, Communication res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("instantiatesCanonical")) {
      JsonArray array = getJArray(json, "instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesCanonical().add(new CanonicalType());
        } else {;
          res.getInstantiatesCanonical().add(parseCanonical(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesCanonical")) {
      JsonArray array = getJArray(json, "_instantiatesCanonical");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesCanonical().size())
          res.getInstantiatesCanonical().add(parseCanonical(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesCanonical().get(i));
      }
    };
    if (json.has("instantiatesUri")) {
      JsonArray array = getJArray(json, "instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getInstantiatesUri().add(new UriType());
        } else {;
          res.getInstantiatesUri().add(parseUri(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_instantiatesUri")) {
      JsonArray array = getJArray(json, "_instantiatesUri");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getInstantiatesUri().size())
          res.getInstantiatesUri().add(parseUri(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getInstantiatesUri().get(i));
      }
    };
    if (json.has("basedOn")) {
      JsonArray array = getJArray(json, "basedOn");
      for (int i = 0; i < array.size(); i++) {
        res.getBasedOn().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("partOf")) {
      JsonArray array = getJArray(json, "partOf");
      for (int i = 0; i < array.size(); i++) {
        res.getPartOf().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("inResponseTo")) {
      JsonArray array = getJArray(json, "inResponseTo");
      for (int i = 0; i < array.size(); i++) {
        res.getInResponseTo().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.EventStatus.NULL, new Enumerations.EventStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(getJObject(json, "statusReason")));
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(), Enumerations.RequestPriority.NULL, new Enumerations.RequestPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(getJObject(json, "_priority"), res.getPriorityElement());
    if (json.has("medium")) {
      JsonArray array = getJArray(json, "medium");
      for (int i = 0; i < array.size(); i++) {
        res.getMedium().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("topic"))
      res.setTopic(parseCodeableConcept(getJObject(json, "topic")));
    if (json.has("about")) {
      JsonArray array = getJArray(json, "about");
      for (int i = 0; i < array.size(); i++) {
        res.getAbout().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    if (json.has("sent"))
      res.setSentElement(parseDateTime(json.get("sent").getAsString()));
    if (json.has("_sent"))
      parseElementProperties(getJObject(json, "_sent"), res.getSentElement());
    if (json.has("received"))
      res.setReceivedElement(parseDateTime(json.get("received").getAsString()));
    if (json.has("_received"))
      parseElementProperties(getJObject(json, "_received"), res.getReceivedElement());
    if (json.has("recipient")) {
      JsonArray array = getJArray(json, "recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("sender"))
      res.setSender(parseReference(getJObject(json, "sender")));
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("payload")) {
      JsonArray array = getJArray(json, "payload");
      for (int i = 0; i < array.size(); i++) {
        res.getPayload().add(parseCommunicationPayloadComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Communication.CommunicationPayloadComponent parseCommunicationPayloadComponent(JsonObject json) throws IOException, FHIRFormatError {
    Communication.CommunicationPayloadComponent res = new Communication.CommunicationPayloadComponent();
    parseCommunicationPayloadComponentProperties(json, res);
    return res;
  }

  protected void parseCommunicationPayloadComponentProperties(JsonObject json, Communication.CommunicationPayloadComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType content = parseType("content", json);
    if (content != null)
      res.setContent(content);
  }

  protected CommunicationRequest parseCommunicationRequest(JsonObject json) throws IOException, FHIRFormatError {
    CommunicationRequest res = new CommunicationRequest();
    parseCommunicationRequestProperties(json, res);
    return res;
  }

  protected void parseCommunicationRequestProperties(JsonObject json, CommunicationRequest res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "identifier");
      for (int i = 0; i < array.size(); i++) {
        res.getIdentifier().add(parseIdentifier(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("basedOn")) {
      JsonArray array = getJArray(json, "basedOn");
      for (int i = 0; i < array.size(); i++) {
        res.getBasedOn().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("replaces")) {
      JsonArray array = getJArray(json, "replaces");
      for (int i = 0; i < array.size(); i++) {
        res.getReplaces().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("groupIdentifier"))
      res.setGroupIdentifier(parseIdentifier(getJObject(json, "groupIdentifier")));
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.RequestStatus.NULL, new Enumerations.RequestStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("statusReason"))
      res.setStatusReason(parseCodeableConcept(getJObject(json, "statusReason")));
    if (json.has("intent"))
      res.setIntentElement(parseEnumeration(json.get("intent").getAsString(), Enumerations.RequestIntent.NULL, new Enumerations.RequestIntentEnumFactory()));
    if (json.has("_intent"))
      parseElementProperties(getJObject(json, "_intent"), res.getIntentElement());
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("priority"))
      res.setPriorityElement(parseEnumeration(json.get("priority").getAsString(), Enumerations.RequestPriority.NULL, new Enumerations.RequestPriorityEnumFactory()));
    if (json.has("_priority"))
      parseElementProperties(getJObject(json, "_priority"), res.getPriorityElement());
    if (json.has("doNotPerform"))
      res.setDoNotPerformElement(parseBoolean(json.get("doNotPerform").getAsBoolean()));
    if (json.has("_doNotPerform"))
      parseElementProperties(getJObject(json, "_doNotPerform"), res.getDoNotPerformElement());
    if (json.has("medium")) {
      JsonArray array = getJArray(json, "medium");
      for (int i = 0; i < array.size(); i++) {
        res.getMedium().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subject"))
      res.setSubject(parseReference(getJObject(json, "subject")));
    if (json.has("about")) {
      JsonArray array = getJArray(json, "about");
      for (int i = 0; i < array.size(); i++) {
        res.getAbout().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    if (json.has("payload")) {
      JsonArray array = getJArray(json, "payload");
      for (int i = 0; i < array.size(); i++) {
        res.getPayload().add(parseCommunicationRequestPayloadComponent(array.get(i).getAsJsonObject()));
      }
    };
    DataType occurrence = parseType("occurrence", json);
    if (occurrence != null)
      res.setOccurrence(occurrence);
    if (json.has("authoredOn"))
      res.setAuthoredOnElement(parseDateTime(json.get("authoredOn").getAsString()));
    if (json.has("_authoredOn"))
      parseElementProperties(getJObject(json, "_authoredOn"), res.getAuthoredOnElement());
    if (json.has("requester"))
      res.setRequester(parseReference(getJObject(json, "requester")));
    if (json.has("recipient")) {
      JsonArray array = getJArray(json, "recipient");
      for (int i = 0; i < array.size(); i++) {
        res.getRecipient().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("informationProvider")) {
      JsonArray array = getJArray(json, "informationProvider");
      for (int i = 0; i < array.size(); i++) {
        res.getInformationProvider().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("reason")) {
      JsonArray array = getJArray(json, "reason");
      for (int i = 0; i < array.size(); i++) {
        res.getReason().add(parseCodeableReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CommunicationRequest.CommunicationRequestPayloadComponent parseCommunicationRequestPayloadComponent(JsonObject json) throws IOException, FHIRFormatError {
    CommunicationRequest.CommunicationRequestPayloadComponent res = new CommunicationRequest.CommunicationRequestPayloadComponent();
    parseCommunicationRequestPayloadComponentProperties(json, res);
    return res;
  }

  protected void parseCommunicationRequestPayloadComponentProperties(JsonObject json, CommunicationRequest.CommunicationRequestPayloadComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    DataType content = parseType("content", json);
    if (content != null)
      res.setContent(content);
  }

  protected CompartmentDefinition parseCompartmentDefinition(JsonObject json) throws IOException, FHIRFormatError {
    CompartmentDefinition res = new CompartmentDefinition();
    parseCompartmentDefinitionProperties(json, res);
    return res;
  }

  protected void parseCompartmentDefinitionProperties(JsonObject json, CompartmentDefinition res) throws IOException, FHIRFormatError {
    parseCanonicalResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("version"))
      res.setVersionElement(parseString(json.get("version").getAsString()));
    if (json.has("_version"))
      parseElementProperties(getJObject(json, "_version"), res.getVersionElement());
    DataType versionAlgorithm = parseType("versionAlgorithm", json);
    if (versionAlgorithm != null)
      res.setVersionAlgorithm(versionAlgorithm);
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.PublicationStatus.NULL, new Enumerations.PublicationStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("experimental"))
      res.setExperimentalElement(parseBoolean(json.get("experimental").getAsBoolean()));
    if (json.has("_experimental"))
      parseElementProperties(getJObject(json, "_experimental"), res.getExperimentalElement());
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("publisher"))
      res.setPublisherElement(parseString(json.get("publisher").getAsString()));
    if (json.has("_publisher"))
      parseElementProperties(getJObject(json, "_publisher"), res.getPublisherElement());
    if (json.has("contact")) {
      JsonArray array = getJArray(json, "contact");
      for (int i = 0; i < array.size(); i++) {
        res.getContact().add(parseContactDetail(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("description"))
      res.setDescriptionElement(parseMarkdown(json.get("description").getAsString()));
    if (json.has("_description"))
      parseElementProperties(getJObject(json, "_description"), res.getDescriptionElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("purpose"))
      res.setPurposeElement(parseMarkdown(json.get("purpose").getAsString()));
    if (json.has("_purpose"))
      parseElementProperties(getJObject(json, "_purpose"), res.getPurposeElement());
    if (json.has("code"))
      res.setCodeElement(parseEnumeration(json.get("code").getAsString(), Enumerations.CompartmentType.NULL, new Enumerations.CompartmentTypeEnumFactory()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("search"))
      res.setSearchElement(parseBoolean(json.get("search").getAsBoolean()));
    if (json.has("_search"))
      parseElementProperties(getJObject(json, "_search"), res.getSearchElement());
    if (json.has("resource")) {
      JsonArray array = getJArray(json, "resource");
      for (int i = 0; i < array.size(); i++) {
        res.getResource().add(parseCompartmentDefinitionResourceComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected CompartmentDefinition.CompartmentDefinitionResourceComponent parseCompartmentDefinitionResourceComponent(JsonObject json) throws IOException, FHIRFormatError {
    CompartmentDefinition.CompartmentDefinitionResourceComponent res = new CompartmentDefinition.CompartmentDefinitionResourceComponent();
    parseCompartmentDefinitionResourceComponentProperties(json, res);
    return res;
  }

  protected void parseCompartmentDefinitionResourceComponentProperties(JsonObject json, CompartmentDefinition.CompartmentDefinitionResourceComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("code"))
      res.setCodeElement(parseCode(json.get("code").getAsString()));
    if (json.has("_code"))
      parseElementProperties(getJObject(json, "_code"), res.getCodeElement());
    if (json.has("param")) {
      JsonArray array = getJArray(json, "param");
      for (int i = 0; i < array.size(); i++) {
        if (array.get(i).isJsonNull()) {
          res.getParam().add(new StringType());
        } else {;
          res.getParam().add(parseString(array.get(i).getAsString()));
        }
      }
    };
    if (json.has("_param")) {
      JsonArray array = getJArray(json, "_param");
      for (int i = 0; i < array.size(); i++) {
        if (i == res.getParam().size())
          res.getParam().add(parseString(null));
        if (array.get(i) instanceof JsonObject) 
          parseElementProperties(array.get(i).getAsJsonObject(), res.getParam().get(i));
      }
    };
    if (json.has("documentation"))
      res.setDocumentationElement(parseString(json.get("documentation").getAsString()));
    if (json.has("_documentation"))
      parseElementProperties(getJObject(json, "_documentation"), res.getDocumentationElement());
    if (json.has("startParam"))
      res.setStartParamElement(parseUri(json.get("startParam").getAsString()));
    if (json.has("_startParam"))
      parseElementProperties(getJObject(json, "_startParam"), res.getStartParamElement());
    if (json.has("endParam"))
      res.setEndParamElement(parseUri(json.get("endParam").getAsString()));
    if (json.has("_endParam"))
      parseElementProperties(getJObject(json, "_endParam"), res.getEndParamElement());
  }

  protected Composition parseComposition(JsonObject json) throws IOException, FHIRFormatError {
    Composition res = new Composition();
    parseCompositionProperties(json, res);
    return res;
  }

  protected void parseCompositionProperties(JsonObject json, Composition res) throws IOException, FHIRFormatError {
    parseDomainResourceProperties(json, res);
    if (json.has("url"))
      res.setUrlElement(parseUri(json.get("url").getAsString()));
    if (json.has("_url"))
      parseElementProperties(getJObject(json, "_url"), res.getUrlElement());
    if (json.has("identifier")) {
      JsonArray array = getJArray(json, "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(getJObject(json, "_version"), res.getVersionElement());
    if (json.has("status"))
      res.setStatusElement(parseEnumeration(json.get("status").getAsString(), Enumerations.CompositionStatus.NULL, new Enumerations.CompositionStatusEnumFactory()));
    if (json.has("_status"))
      parseElementProperties(getJObject(json, "_status"), res.getStatusElement());
    if (json.has("type"))
      res.setType(parseCodeableConcept(getJObject(json, "type")));
    if (json.has("category")) {
      JsonArray array = getJArray(json, "category");
      for (int i = 0; i < array.size(); i++) {
        res.getCategory().add(parseCodeableConcept(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("subject")) {
      JsonArray array = getJArray(json, "subject");
      for (int i = 0; i < array.size(); i++) {
        res.getSubject().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("encounter"))
      res.setEncounter(parseReference(getJObject(json, "encounter")));
    if (json.has("date"))
      res.setDateElement(parseDateTime(json.get("date").getAsString()));
    if (json.has("_date"))
      parseElementProperties(getJObject(json, "_date"), res.getDateElement());
    if (json.has("useContext")) {
      JsonArray array = getJArray(json, "useContext");
      for (int i = 0; i < array.size(); i++) {
        res.getUseContext().add(parseUsageContext(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("author")) {
      JsonArray array = getJArray(json, "author");
      for (int i = 0; i < array.size(); i++) {
        res.getAuthor().add(parseReference(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("name"))
      res.setNameElement(parseString(json.get("name").getAsString()));
    if (json.has("_name"))
      parseElementProperties(getJObject(json, "_name"), res.getNameElement());
    if (json.has("title"))
      res.setTitleElement(parseString(json.get("title").getAsString()));
    if (json.has("_title"))
      parseElementProperties(getJObject(json, "_title"), res.getTitleElement());
    if (json.has("note")) {
      JsonArray array = getJArray(json, "note");
      for (int i = 0; i < array.size(); i++) {
        res.getNote().add(parseAnnotation(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("attester")) {
      JsonArray array = getJArray(json, "attester");
      for (int i = 0; i < array.size(); i++) {
        res.getAttester().add(parseCompositionAttesterComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("custodian"))
      res.setCustodian(parseReference(getJObject(json, "custodian")));
    if (json.has("relatesTo")) {
      JsonArray array = getJArray(json, "relatesTo");
      for (int i = 0; i < array.size(); i++) {
        res.getRelatesTo().add(parseRelatedArtifact(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("event")) {
      JsonArray array = getJArray(json, "event");
      for (int i = 0; i < array.size(); i++) {
        res.getEvent().add(parseCompositionEventComponent(array.get(i).getAsJsonObject()));
      }
    };
    if (json.has("section")) {
      JsonArray array = getJArray(json, "section");
      for (int i = 0; i < array.size(); i++) {
        res.getSection().add(parseCompositionSectionComponent(array.get(i).getAsJsonObject()));
      }
    };
  }

  protected Composition.CompositionAttesterComponent parseCompositionAttesterComponent(JsonObject json) throws IOException, FHIRFormatError {
    Composition.CompositionAttesterComponent res = new Composition.CompositionAttesterComponent();
    parseCompositionAttesterComponentProperties(json, res);
    return res;
  }

  protected void parseCompositionAttesterComponentProperties(JsonObject json, Composition.CompositionAttesterComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);
    if (json.has("mode"))
      res.setMode(parseCodeableConcept(getJObject(json, "mode")));
    if (json.has("time"))
      res.setTimeElement(parseDateTime(json.get("time").getAsString()));
    if (json.has("_time"))
      parseElementProperties(getJObject(json, "_time"), res.getTimeElement());
    if (json.has("party"))
      res.setParty(parseReference(getJObject(json, "party")));
  }

  protected Composition.CompositionEventComponent parseCompositionEventComponent(JsonObject json) throws IOException, FHIRFormatError {
    Composition.CompositionEventComponent res = new Composition.CompositionEventComponent();
    parseCompositionEventComponentProperties(json, res);
    return res;
  }

  protected void parseCompositionEventComponentProperties(JsonObject json, Composition.CompositionEventComponent res) throws IOException, FHIRFormatError {
    parseBackboneElementProperties(json, res);