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 Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0



import org.hl7.fhir.r5.model.*;
import org.hl7.fhir.r5.model.StringType;
import org.hl7.fhir.utilities.Utilities;
import org.hl7.fhir.exceptions.FHIRFormatError;
import org.hl7.fhir.exceptions.FHIRException;
import org.hl7.fhir.utilities.turtle.Turtle.*;
import java.io.IOException;

public class RdfParser extends RdfParserBase {

  public RdfParser() {
    super();
  }

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

  private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
    decorateCode(t, value);
  }


  protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
    decorateCode(t, value);
  }

  protected void composeString(Complex parent, String parentType, String name, StringType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeInteger64(Complex parent, String parentType, String name, Integer64Type value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeId(Complex parent, String parentType, String name, IdType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) {
    if (value == null)
      return;
    Complex t = parent.predicate("fhir:"+name, index > -1);
    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
    composeElement(t, parentType, name, value, index);
  }

  protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) {
    composeElement(t, parentType, name, element, index);
    for (int i = 0; i < element.getModifierExtension().size(); i++) {
      composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i);
    }
  }

  protected void composeBackboneType(Complex t, String parentType, String name, BackboneType element, int index) {
    composeDataType(t, parentType, name, element, index);
    for (int i = 0; i < element.getModifierExtension().size(); i++) {
      composeExtension(t, "BackboneType", "modifierExtension", element.getModifierExtension().get(i), i);
    }
  }

  protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) {
    composeElement(t, parentType, name, element, index);
  }

  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
    composeBase(t, parentType, name, element, index);
    if (element.hasIdElement()) {
      composeString(t, "Element", "id", element.getIdElement(), -1);
    }
    for (int i = 0; i < element.getExtension().size(); i++) {
      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
    }
  }

  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Address", name, element, index);
    if (element.hasUseElement()) {
      composeEnum(t, "Address", "use", element.getUseElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "Address", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getLine().size(); i++) {
      composeString(t, "Address", "line", element.getLine().get(i), i);
    }
    if (element.hasCityElement()) {
      composeString(t, "Address", "city", element.getCityElement(), -1);
    }
    if (element.hasDistrictElement()) {
      composeString(t, "Address", "district", element.getDistrictElement(), -1);
    }
    if (element.hasStateElement()) {
      composeString(t, "Address", "state", element.getStateElement(), -1);
    }
    if (element.hasPostalCodeElement()) {
      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
    }
    if (element.hasCountryElement()) {
      composeString(t, "Address", "country", element.getCountryElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Address", "period", element.getPeriod(), -1);
    }
  }

  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeQuantity(t, "Age", name, element, index);
  }

  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Annotation", name, element, index);
    if (element.hasAuthor()) {
      composeType(t, "Annotation", "author", element.getAuthor(), -1);
    }
    if (element.hasTimeElement()) {
      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
    }
    if (element.hasTextElement()) {
      composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1);
    }
  }

  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Attachment", name, element, index);
    if (element.hasContentTypeElement()) {
      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
    }
    if (element.hasLanguageElement()) {
      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
    }
    if (element.hasDataElement()) {
      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "Attachment", "url", element.getUrlElement(), -1);
    }
    if (element.hasSizeElement()) {
      composeInteger64(t, "Attachment", "size", element.getSizeElement(), -1);
    }
    if (element.hasHashElement()) {
      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
    }
    if (element.hasCreationElement()) {
      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
    }
    if (element.hasHeightElement()) {
      composePositiveInt(t, "Attachment", "height", element.getHeightElement(), -1);
    }
    if (element.hasWidthElement()) {
      composePositiveInt(t, "Attachment", "width", element.getWidthElement(), -1);
    }
    if (element.hasFramesElement()) {
      composePositiveInt(t, "Attachment", "frames", element.getFramesElement(), -1);
    }
    if (element.hasDurationElement()) {
      composeDecimal(t, "Attachment", "duration", element.getDurationElement(), -1);
    }
    if (element.hasPagesElement()) {
      composePositiveInt(t, "Attachment", "pages", element.getPagesElement(), -1);
    }
  }

  protected void composeAvailability(Complex parent, String parentType, String name, Availability element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Availability", name, element, index);
    for (int i = 0; i < element.getAvailableTime().size(); i++) {
      composeAvailabilityAvailableTimeComponent(t, "Availability", "availableTime", element.getAvailableTime().get(i), i);
    }
    for (int i = 0; i < element.getNotAvailableTime().size(); i++) {
      composeAvailabilityNotAvailableTimeComponent(t, "Availability", "notAvailableTime", element.getNotAvailableTime().get(i), i);
    }
  }

  protected void composeAvailabilityAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityAvailableTimeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "availableTime", name, element, index);
    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
      composeEnum(t, "AvailabilityAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
    }
    if (element.hasAllDayElement()) {
      composeBoolean(t, "AvailabilityAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
    }
    if (element.hasAvailableStartTimeElement()) {
      composeTime(t, "AvailabilityAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
    }
    if (element.hasAvailableEndTimeElement()) {
      composeTime(t, "AvailabilityAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
    }
  }

  protected void composeAvailabilityNotAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityNotAvailableTimeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "notAvailableTime", name, element, index);
    if (element.hasDescriptionElement()) {
      composeString(t, "AvailabilityNotAvailableTimeComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasDuring()) {
      composePeriod(t, "AvailabilityNotAvailableTimeComponent", "during", element.getDuring(), -1);
    }
  }

  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "CodeableConcept", name, element, index);
    decorateCodeableConcept(t, element);
    for (int i = 0; i < element.getCoding().size(); i++) {
      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
    }
    if (element.hasTextElement()) {
      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
    }
  }

  protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "CodeableReference", name, element, index);
    if (element.hasConcept()) {
      composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "CodeableReference", "reference", element.getReference(), -1);
    }
  }

  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Coding", name, element, index);
    decorateCoding(t, element);
    if (element.hasSystemElement()) {
      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Coding", "version", element.getVersionElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
    }
    if (element.hasUserSelectedElement()) {
      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
    }
  }

  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "ContactDetail", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
    }
  }

  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "ContactPoint", name, element, index);
    if (element.hasSystemElement()) {
      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
    }
    if (element.hasRankElement()) {
      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
    }
  }

  protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Contributor", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Contributor", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
    }
  }

  protected void composeCount(Complex parent, String parentType, String name, Count element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeQuantity(t, "Count", name, element, index);
  }

  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "DataRequirement", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i);
    }
    if (element.hasSubject()) {
      composeType(t, "DataRequirement", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getMustSupport().size(); i++) {
      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
    }
    for (int i = 0; i < element.getCodeFilter().size(); i++) {
      composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
    }
    for (int i = 0; i < element.getDateFilter().size(); i++) {
      composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
    }
    for (int i = 0; i < element.getValueFilter().size(); i++) {
      composeDataRequirementValueFilterComponent(t, "DataRequirement", "valueFilter", element.getValueFilter().get(i), i);
    }
    if (element.hasLimitElement()) {
      composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1);
    }
    for (int i = 0; i < element.getSort().size(); i++) {
      composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i);
    }
  }

  protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "codeFilter", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasSearchParamElement()) {
      composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i);
    }
  }

  protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "dateFilter", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasSearchParamElement()) {
      composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeDataRequirementValueFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementValueFilterComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "valueFilter", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "DataRequirementValueFilterComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasSearchParamElement()) {
      composeString(t, "DataRequirementValueFilterComponent", "searchParam", element.getSearchParamElement(), -1);
    }
    if (element.hasComparatorElement()) {
      composeEnum(t, "DataRequirementValueFilterComponent", "comparator", element.getComparatorElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "DataRequirementValueFilterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "sort", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasDirectionElement()) {
      composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1);
    }
  }

  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeQuantity(t, "Distance", name, element, index);
  }

  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneType(t, "Dosage", name, element, index);
    if (element.hasSequenceElement()) {
      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "Dosage", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getAdditionalInstruction().size(); i++) {
      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
    }
    if (element.hasPatientInstructionElement()) {
      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
    }
    if (element.hasTiming()) {
      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
    }
    if (element.hasAsNeededElement()) {
      composeBoolean(t, "Dosage", "asNeeded", element.getAsNeededElement(), -1);
    }
    for (int i = 0; i < element.getAsNeededFor().size(); i++) {
      composeCodeableConcept(t, "Dosage", "asNeededFor", element.getAsNeededFor().get(i), i);
    }
    if (element.hasSite()) {
      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
    }
    if (element.hasRoute()) {
      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
    }
    for (int i = 0; i < element.getDoseAndRate().size(); i++) {
      composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i);
    }
    for (int i = 0; i < element.getMaxDosePerPeriod().size(); i++) {
      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod().get(i), i);
    }
    if (element.hasMaxDosePerAdministration()) {
      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
    }
    if (element.hasMaxDosePerLifetime()) {
      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
    }
  }

  protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "doseAndRate", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1);
    }
    if (element.hasDose()) {
      composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1);
    }
    if (element.hasRate()) {
      composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1);
    }
  }

  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeQuantity(t, "Duration", name, element, index);
  }

  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneType(t, "ElementDefinition", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
    }
    for (int i = 0; i < element.getRepresentation().size(); i++) {
      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
    }
    if (element.hasSliceNameElement()) {
      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
    }
    if (element.hasSliceIsConstrainingElement()) {
      composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1);
    }
    if (element.hasLabelElement()) {
      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
    }
    if (element.hasSlicing()) {
      composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
    }
    if (element.hasShortElement()) {
      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
    }
    if (element.hasRequirementsElement()) {
      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
    }
    for (int i = 0; i < element.getAlias().size(); i++) {
      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
    }
    if (element.hasMinElement()) {
      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
    }
    if (element.hasBase()) {
      composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
    }
    if (element.hasContentReferenceElement()) {
      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
    }
    if (element.hasDefaultValue()) {
      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
    }
    if (element.hasMeaningWhenMissingElement()) {
      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
    }
    if (element.hasOrderMeaningElement()) {
      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
    }
    if (element.hasFixed()) {
      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
    }
    if (element.hasPattern()) {
      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
    }
    for (int i = 0; i < element.getExample().size(); i++) {
      composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
    }
    if (element.hasMinValue()) {
      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
    }
    if (element.hasMaxValue()) {
      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
    }
    if (element.hasMaxLengthElement()) {
      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getConstraint().size(); i++) {
      composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
    }
    if (element.hasMustHaveValueElement()) {
      composeBoolean(t, "ElementDefinition", "mustHaveValue", element.getMustHaveValueElement(), -1);
    }
    for (int i = 0; i < element.getValueAlternatives().size(); i++) {
      composeCanonical(t, "ElementDefinition", "valueAlternatives", element.getValueAlternatives().get(i), i);
    }
    if (element.hasMustSupportElement()) {
      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
    }
    if (element.hasIsModifierElement()) {
      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
    }
    if (element.hasIsModifierReasonElement()) {
      composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1);
    }
    if (element.hasIsSummaryElement()) {
      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
    }
    if (element.hasBinding()) {
      composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
    }
    for (int i = 0; i < element.getMapping().size(); i++) {
      composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
    }
  }

  protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "slicing", name, element, index);
    for (int i = 0; i < element.getDiscriminator().size(); i++) {
      composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasOrderedElement()) {
      composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1);
    }
    if (element.hasRulesElement()) {
      composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1);
    }
  }

  protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "discriminator", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasPathElement()) {
      composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1);
    }
  }

  protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "base", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasMinElement()) {
      composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1);
    }
  }

  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "type", name, element, index);
    if (element.hasCodeElement()) {
      composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i);
    }
    for (int i = 0; i < element.getTargetProfile().size(); i++) {
      composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i);
    }
    for (int i = 0; i < element.getAggregation().size(); i++) {
      composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i);
    }
    if (element.hasVersioningElement()) {
      composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1);
    }
  }

  protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "example", name, element, index);
    if (element.hasLabelElement()) {
      composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "constraint", name, element, index);
    if (element.hasKeyElement()) {
      composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1);
    }
    if (element.hasRequirementsElement()) {
      composeMarkdown(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1);
    }
    if (element.hasSeverityElement()) {
      composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1);
    }
    if (element.hasSuppressElement()) {
      composeBoolean(t, "ElementDefinitionConstraintComponent", "suppress", element.getSuppressElement(), -1);
    }
    if (element.hasHumanElement()) {
      composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasSourceElement()) {
      composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1);
    }
  }

  protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "binding", name, element, index);
    if (element.hasStrengthElement()) {
      composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1);
    }
    for (int i = 0; i < element.getAdditional().size(); i++) {
      composeElementDefinitionBindingAdditionalComponent(t, "ElementDefinitionBindingComponent", "additional", element.getAdditional().get(i), i);
    }
  }

  protected void composeElementDefinitionBindingAdditionalComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingAdditionalComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "additional", name, element, index);
    if (element.hasPurposeElement()) {
      composeEnum(t, "ElementDefinitionBindingAdditionalComponent", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "ElementDefinitionBindingAdditionalComponent", "valueSet", element.getValueSetElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "ElementDefinitionBindingAdditionalComponent", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasShortDocoElement()) {
      composeString(t, "ElementDefinitionBindingAdditionalComponent", "shortDoco", element.getShortDocoElement(), -1);
    }
    for (int i = 0; i < element.getUsage().size(); i++) {
      composeUsageContext(t, "ElementDefinitionBindingAdditionalComponent", "usage", element.getUsage().get(i), i);
    }
    if (element.hasAnyElement()) {
      composeBoolean(t, "ElementDefinitionBindingAdditionalComponent", "any", element.getAnyElement(), -1);
    }
  }

  protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "mapping", name, element, index);
    if (element.hasIdentityElement()) {
      composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
    }
    if (element.hasLanguageElement()) {
      composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1);
    }
    if (element.hasMapElement()) {
      composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Expression", name, element, index);
    if (element.hasDescriptionElement()) {
      composeString(t, "Expression", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasNameElement()) {
      composeCode(t, "Expression", "name", element.getNameElement(), -1);
    }
    if (element.hasLanguageElement()) {
      composeCode(t, "Expression", "language", element.getLanguageElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "Expression", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasReferenceElement()) {
      composeUri(t, "Expression", "reference", element.getReferenceElement(), -1);
    }
  }

  protected void composeExtendedContactDetail(Complex parent, String parentType, String name, ExtendedContactDetail element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "ExtendedContactDetail", name, element, index);
    if (element.hasPurpose()) {
      composeCodeableConcept(t, "ExtendedContactDetail", "purpose", element.getPurpose(), -1);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeHumanName(t, "ExtendedContactDetail", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "ExtendedContactDetail", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasAddress()) {
      composeAddress(t, "ExtendedContactDetail", "address", element.getAddress(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "ExtendedContactDetail", "organization", element.getOrganization(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ExtendedContactDetail", "period", element.getPeriod(), -1);
    }
  }

  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Extension", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "Extension", "value", element.getValue(), -1);
    }
  }

  protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "HumanName", name, element, index);
    if (element.hasUseElement()) {
      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "HumanName", "text", element.getTextElement(), -1);
    }
    if (element.hasFamilyElement()) {
      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
    }
    for (int i = 0; i < element.getGiven().size(); i++) {
      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
    }
    for (int i = 0; i < element.getPrefix().size(); i++) {
      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
    }
    for (int i = 0; i < element.getSuffix().size(); i++) {
      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
    }
  }

  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Identifier", name, element, index);
    if (element.hasUseElement()) {
      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
    }
    if (element.hasSystemElement()) {
      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "Identifier", "value", element.getValueElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
    }
    if (element.hasAssigner()) {
      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
    }
  }

  protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneType(t, "MarketingStatus", name, element, index);
    if (element.hasCountry()) {
      composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1);
    }
    if (element.hasJurisdiction()) {
      composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1);
    }
    if (element.hasDateRange()) {
      composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1);
    }
    if (element.hasRestoreDateElement()) {
      composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1);
    }
  }

  protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Meta", name, element, index);
    if (element.hasVersionIdElement()) {
      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
    }
    if (element.hasLastUpdatedElement()) {
      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
    }
    if (element.hasSourceElement()) {
      composeUri(t, "Meta", "source", element.getSourceElement(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i);
    }
    for (int i = 0; i < element.getSecurity().size(); i++) {
      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
    }
    for (int i = 0; i < element.getTag().size(); i++) {
      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
    }
  }

  protected void composeMonetaryComponent(Complex parent, String parentType, String name, MonetaryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "MonetaryComponent", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "MonetaryComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MonetaryComponent", "code", element.getCode(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "MonetaryComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "MonetaryComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Money", name, element, index);
    if (element.hasValueElement()) {
      composeDecimal(t, "Money", "value", element.getValueElement(), -1);
    }
    if (element.hasCurrencyElement()) {
      composeCode(t, "Money", "currency", element.getCurrencyElement(), -1);
    }
  }

  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Narrative", name, element, index);
    if (element.hasStatusElement()) {
      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
    }
    if (element.hasDiv()) {
      composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1);
    }
  }

  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "ParameterDefinition", name, element, index);
    if (element.hasNameElement()) {
      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
    }
    if (element.hasMinElement()) {
      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1);
    }
  }

  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Period", name, element, index);
    if (element.hasStartElement()) {
      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
    }
    if (element.hasEndElement()) {
      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
    }
  }

  protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneType(t, "ProductShelfLife", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1);
    }
    if (element.hasPeriod()) {
      composeType(t, "ProductShelfLife", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) {
      composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i);
    }
  }

  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Quantity", name, element, index);
    if (element.hasValueElement()) {
      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
    }
    if (element.hasComparatorElement()) {
      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
    }
    if (element.hasUnitElement()) {
      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
    }
    if (element.hasSystemElement()) {
      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
    }
  }

  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Range", name, element, index);
    if (element.hasLow()) {
      composeQuantity(t, "Range", "low", element.getLow(), -1);
    }
    if (element.hasHigh()) {
      composeQuantity(t, "Range", "high", element.getHigh(), -1);
    }
  }

  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Ratio", name, element, index);
    if (element.hasNumerator()) {
      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
    }
    if (element.hasDenominator()) {
      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
    }
  }

  protected void composeRatioRange(Complex parent, String parentType, String name, RatioRange element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "RatioRange", name, element, index);
    if (element.hasLowNumerator()) {
      composeQuantity(t, "RatioRange", "lowNumerator", element.getLowNumerator(), -1);
    }
    if (element.hasHighNumerator()) {
      composeQuantity(t, "RatioRange", "highNumerator", element.getHighNumerator(), -1);
    }
    if (element.hasDenominator()) {
      composeQuantity(t, "RatioRange", "denominator", element.getDenominator(), -1);
    }
  }

  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Reference", name, element, index);
    if (element.hasReferenceElement()) {
      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
    }
    if (element.hasTypeElement()) {
      composeUri(t, "Reference", "type", element.getTypeElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
    }
  }

  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "RelatedArtifact", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "RelatedArtifact", "classifier", element.getClassifier().get(i), i);
    }
    if (element.hasLabelElement()) {
      composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
    }
    if (element.hasCitationElement()) {
      composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
    }
    if (element.hasDocument()) {
      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
    }
    if (element.hasResourceElement()) {
      composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1);
    }
    if (element.hasResourceReference()) {
      composeReference(t, "RelatedArtifact", "resourceReference", element.getResourceReference(), -1);
    }
    if (element.hasPublicationStatusElement()) {
      composeEnum(t, "RelatedArtifact", "publicationStatus", element.getPublicationStatusElement(), -1);
    }
    if (element.hasPublicationDateElement()) {
      composeDate(t, "RelatedArtifact", "publicationDate", element.getPublicationDateElement(), -1);
    }
  }

  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "SampledData", name, element, index);
    if (element.hasOrigin()) {
      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
    }
    if (element.hasIntervalElement()) {
      composeDecimal(t, "SampledData", "interval", element.getIntervalElement(), -1);
    }
    if (element.hasIntervalUnitElement()) {
      composeCode(t, "SampledData", "intervalUnit", element.getIntervalUnitElement(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
    }
    if (element.hasLowerLimitElement()) {
      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
    }
    if (element.hasUpperLimitElement()) {
      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
    }
    if (element.hasDimensionsElement()) {
      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
    }
    if (element.hasCodeMapElement()) {
      composeCanonical(t, "SampledData", "codeMap", element.getCodeMapElement(), -1);
    }
    if (element.hasOffsetsElement()) {
      composeString(t, "SampledData", "offsets", element.getOffsetsElement(), -1);
    }
    if (element.hasDataElement()) {
      composeString(t, "SampledData", "data", element.getDataElement(), -1);
    }
  }

  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "Signature", name, element, index);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCoding(t, "Signature", "type", element.getType().get(i), i);
    }
    if (element.hasWhenElement()) {
      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
    }
    if (element.hasWho()) {
      composeReference(t, "Signature", "who", element.getWho(), -1);
    }
    if (element.hasOnBehalfOf()) {
      composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
    }
    if (element.hasTargetFormatElement()) {
      composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1);
    }
    if (element.hasSigFormatElement()) {
      composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1);
    }
    if (element.hasDataElement()) {
      composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1);
    }
  }

  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneType(t, "Timing", name, element, index);
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
    }
    if (element.hasRepeat()) {
      composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
    }
  }

  protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeElement(t, "repeat", name, element, index);
    if (element.hasBounds()) {
      composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1);
    }
    if (element.hasCountElement()) {
      composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1);
    }
    if (element.hasCountMaxElement()) {
      composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1);
    }
    if (element.hasDurationElement()) {
      composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1);
    }
    if (element.hasDurationMaxElement()) {
      composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1);
    }
    if (element.hasDurationUnitElement()) {
      composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1);
    }
    if (element.hasFrequencyElement()) {
      composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1);
    }
    if (element.hasFrequencyMaxElement()) {
      composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1);
    }
    if (element.hasPeriodElement()) {
      composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1);
    }
    if (element.hasPeriodMaxElement()) {
      composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1);
    }
    if (element.hasPeriodUnitElement()) {
      composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1);
    }
    for (int i = 0; i < element.getDayOfWeek().size(); i++) {
      composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i);
    }
    for (int i = 0; i < element.getTimeOfDay().size(); i++) {
      composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i);
    }
    for (int i = 0; i < element.getWhen().size(); i++) {
      composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i);
    }
    if (element.hasOffsetElement()) {
      composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1);
    }
  }

  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "TriggerDefinition", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "TriggerDefinition", "code", element.getCode(), -1);
    }
    if (element.hasSubscriptionTopicElement()) {
      composeCanonical(t, "TriggerDefinition", "subscriptionTopic", element.getSubscriptionTopicElement(), -1);
    }
    if (element.hasTiming()) {
      composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1);
    }
    for (int i = 0; i < element.getData().size(); i++) {
      composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i);
    }
    if (element.hasCondition()) {
      composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1);
    }
  }

  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "UsageContext", name, element, index);
    if (element.hasCode()) {
      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "UsageContext", "value", element.getValue(), -1);
    }
  }

  protected void composeVirtualServiceDetail(Complex parent, String parentType, String name, VirtualServiceDetail element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDataType(t, "VirtualServiceDetail", name, element, index);
    if (element.hasChannelType()) {
      composeCoding(t, "VirtualServiceDetail", "channelType", element.getChannelType(), -1);
    }
    if (element.hasAddress()) {
      composeType(t, "VirtualServiceDetail", "address", element.getAddress(), -1);
    }
    for (int i = 0; i < element.getAdditionalInfo().size(); i++) {
      composeUrl(t, "VirtualServiceDetail", "additionalInfo", element.getAdditionalInfo().get(i), i);
    }
    if (element.hasMaxParticipantsElement()) {
      composePositiveInt(t, "VirtualServiceDetail", "maxParticipants", element.getMaxParticipantsElement(), -1);
    }
    if (element.hasSessionKeyElement()) {
      composeString(t, "VirtualServiceDetail", "sessionKey", element.getSessionKeyElement(), -1);
    }
  }

  protected void composeCanonicalResource(Complex t, String parentType, String name, CanonicalResource element, int index) {
    composeDomainResource(t, parentType, name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "CanonicalResource", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CanonicalResource", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "CanonicalResource", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "CanonicalResource", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "CanonicalResource", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CanonicalResource", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CanonicalResource", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "CanonicalResource", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "CanonicalResource", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "CanonicalResource", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "CanonicalResource", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CanonicalResource", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "CanonicalResource", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "CanonicalResource", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "CanonicalResource", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "CanonicalResource", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "CanonicalResource", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
  }

  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
    composeResource(t, parentType, name, element, index);
    if (element.hasText()) {
      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
    }
    for (int i = 0; i < element.getContained().size(); i++) {
      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
    }
    for (int i = 0; i < element.getExtension().size(); i++) {
      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
    }
    for (int i = 0; i < element.getModifierExtension().size(); i++) {
      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
    }
  }

  protected void composeMetadataResource(Complex t, String parentType, String name, MetadataResource element, int index) {
    composeCanonicalResource(t, parentType, name, element, index);
    if (element.hasApprovalDateElement()) {
      composeDate(t, "MetadataResource", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "MetadataResource", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "MetadataResource", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "MetadataResource", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "MetadataResource", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "MetadataResource", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "MetadataResource", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "MetadataResource", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "MetadataResource", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
  }

  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
    composeBase(t, parentType, name, element, index);
    if (element.hasIdElement()) {
      composeId(t, "Resource", "id", element.getIdElement(), -1);
    }
    if (element.hasMeta()) {
      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
    }
    if (element.hasImplicitRulesElement()) {
      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
    }
    if (element.hasLanguageElement()) {
      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
    }
  }

  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Account", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
    }
    if (element.hasBillingStatus()) {
      composeCodeableConcept(t, "Account", "billingStatus", element.getBillingStatus(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Account", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "Account", "subject", element.getSubject().get(i), i);
    }
    if (element.hasServicePeriod()) {
      composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1);
    }
    for (int i = 0; i < element.getCoverage().size(); i++) {
      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
    }
    if (element.hasOwner()) {
      composeReference(t, "Account", "owner", element.getOwner(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Account", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getGuarantor().size(); i++) {
      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeAccountDiagnosisComponent(t, "Account", "diagnosis", element.getDiagnosis().get(i), i);
    }
    for (int i = 0; i < element.getProcedure().size(); i++) {
      composeAccountProcedureComponent(t, "Account", "procedure", element.getProcedure().get(i), i);
    }
    for (int i = 0; i < element.getRelatedAccount().size(); i++) {
      composeAccountRelatedAccountComponent(t, "Account", "relatedAccount", element.getRelatedAccount().get(i), i);
    }
    if (element.hasCurrency()) {
      composeCodeableConcept(t, "Account", "currency", element.getCurrency(), -1);
    }
    for (int i = 0; i < element.getBalance().size(); i++) {
      composeAccountBalanceComponent(t, "Account", "balance", element.getBalance().get(i), i);
    }
    if (element.hasCalculatedAtElement()) {
      composeInstant(t, "Account", "calculatedAt", element.getCalculatedAtElement(), -1);
    }
  }

  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "coverage", name, element, index);
    if (element.hasCoverage()) {
      composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1);
    }
    if (element.hasPriorityElement()) {
      composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1);
    }
  }

  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "guarantor", name, element, index);
    if (element.hasParty()) {
      composeReference(t, "GuarantorComponent", "party", element.getParty(), -1);
    }
    if (element.hasOnHoldElement()) {
      composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeAccountDiagnosisComponent(Complex parent, String parentType, String name, Account.AccountDiagnosisComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "diagnosis", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "AccountDiagnosisComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasCondition()) {
      composeCodeableReference(t, "AccountDiagnosisComponent", "condition", element.getCondition(), -1);
    }
    if (element.hasDateOfDiagnosisElement()) {
      composeDateTime(t, "AccountDiagnosisComponent", "dateOfDiagnosis", element.getDateOfDiagnosisElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "AccountDiagnosisComponent", "type", element.getType().get(i), i);
    }
    if (element.hasOnAdmissionElement()) {
      composeBoolean(t, "AccountDiagnosisComponent", "onAdmission", element.getOnAdmissionElement(), -1);
    }
    for (int i = 0; i < element.getPackageCode().size(); i++) {
      composeCodeableConcept(t, "AccountDiagnosisComponent", "packageCode", element.getPackageCode().get(i), i);
    }
  }

  protected void composeAccountProcedureComponent(Complex parent, String parentType, String name, Account.AccountProcedureComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "procedure", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "AccountProcedureComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableReference(t, "AccountProcedureComponent", "code", element.getCode(), -1);
    }
    if (element.hasDateOfServiceElement()) {
      composeDateTime(t, "AccountProcedureComponent", "dateOfService", element.getDateOfServiceElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "AccountProcedureComponent", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getPackageCode().size(); i++) {
      composeCodeableConcept(t, "AccountProcedureComponent", "packageCode", element.getPackageCode().get(i), i);
    }
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeReference(t, "AccountProcedureComponent", "device", element.getDevice().get(i), i);
    }
  }

  protected void composeAccountRelatedAccountComponent(Complex parent, String parentType, String name, Account.AccountRelatedAccountComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "relatedAccount", name, element, index);
    if (element.hasRelationship()) {
      composeCodeableConcept(t, "AccountRelatedAccountComponent", "relationship", element.getRelationship(), -1);
    }
    if (element.hasAccount()) {
      composeReference(t, "AccountRelatedAccountComponent", "account", element.getAccount(), -1);
    }
  }

  protected void composeAccountBalanceComponent(Complex parent, String parentType, String name, Account.AccountBalanceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "balance", name, element, index);
    if (element.hasAggregate()) {
      composeCodeableConcept(t, "AccountBalanceComponent", "aggregate", element.getAggregate(), -1);
    }
    if (element.hasTerm()) {
      composeCodeableConcept(t, "AccountBalanceComponent", "term", element.getTerm(), -1);
    }
    if (element.hasEstimateElement()) {
      composeBoolean(t, "AccountBalanceComponent", "estimate", element.getEstimateElement(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "AccountBalanceComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "ActivityDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ActivityDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasUsageElement()) {
      composeMarkdown(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ActivityDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getLibrary().size(); i++) {
      composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasTiming()) {
      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
    }
    if (element.hasAsNeeded()) {
      composeType(t, "ActivityDefinition", "asNeeded", element.getAsNeeded(), -1);
    }
    if (element.hasLocation()) {
      composeCodeableReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasProduct()) {
      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
    }
    for (int i = 0; i < element.getDosage().size(); i++) {
      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
    }
    for (int i = 0; i < element.getSpecimenRequirement().size(); i++) {
      composeCanonical(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i);
    }
    for (int i = 0; i < element.getObservationRequirement().size(); i++) {
      composeCanonical(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i);
    }
    for (int i = 0; i < element.getObservationResultRequirement().size(); i++) {
      composeCanonical(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i);
    }
    if (element.hasTransformElement()) {
      composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1);
    }
    for (int i = 0; i < element.getDynamicValue().size(); i++) {
      composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
    }
  }

  protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTypeCanonicalElement()) {
      composeCanonical(t, "ActivityDefinitionParticipantComponent", "typeCanonical", element.getTypeCanonicalElement(), -1);
    }
    if (element.hasTypeReference()) {
      composeReference(t, "ActivityDefinitionParticipantComponent", "typeReference", element.getTypeReference(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1);
    }
    if (element.hasFunction()) {
      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "function", element.getFunction(), -1);
    }
  }

  protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "dynamicValue", name, element, index);
    if (element.hasPathElement()) {
      composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasExpression()) {
      composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composeActorDefinition(Complex parent, String parentType, String name, ActorDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeCanonicalResource(t, "ActorDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ActorDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ActorDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ActorDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ActorDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ActorDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ActorDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ActorDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ActorDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ActorDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ActorDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ActorDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ActorDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ActorDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ActorDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ActorDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ActorDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ActorDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "ActorDefinition", "type", element.getTypeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "ActorDefinition", "documentation", element.getDocumentationElement(), -1);
    }
    for (int i = 0; i < element.getReference().size(); i++) {
      composeUrl(t, "ActorDefinition", "reference", element.getReference().get(i), i);
    }
    if (element.hasCapabilitiesElement()) {
      composeCanonical(t, "ActorDefinition", "capabilities", element.getCapabilitiesElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeCanonical(t, "ActorDefinition", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
  }

  protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "AdministrableProductDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "AdministrableProductDefinition", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getFormOf().size(); i++) {
      composeReference(t, "AdministrableProductDefinition", "formOf", element.getFormOf().get(i), i);
    }
    if (element.hasAdministrableDoseForm()) {
      composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1);
    }
    if (element.hasUnitOfPresentation()) {
      composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
    }
    for (int i = 0; i < element.getProducedFrom().size(); i++) {
      composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeCodeableConcept(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i);
    }
    if (element.hasDevice()) {
      composeReference(t, "AdministrableProductDefinition", "device", element.getDevice(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "AdministrableProductDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeAdministrableProductDefinitionPropertyComponent(t, "AdministrableProductDefinition", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getRouteOfAdministration().size(); i++) {
      composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i);
    }
  }

  protected void composeAdministrableProductDefinitionPropertyComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "AdministrableProductDefinitionPropertyComponent", "value", element.getValue(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "status", element.getStatus(), -1);
    }
  }

  protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "routeOfAdministration", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1);
    }
    if (element.hasFirstDose()) {
      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1);
    }
    if (element.hasMaxSingleDose()) {
      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1);
    }
    if (element.hasMaxDosePerDay()) {
      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1);
    }
    if (element.hasMaxDosePerTreatmentPeriod()) {
      composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1);
    }
    if (element.hasMaxTreatmentPeriod()) {
      composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1);
    }
    for (int i = 0; i < element.getTargetSpecies().size(); i++) {
      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i);
    }
  }

  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "targetSpecies", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) {
      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i);
    }
  }

  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "withdrawalPeriod", name, element, index);
    if (element.hasTissue()) {
      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1);
    }
    if (element.hasValue()) {
      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1);
    }
    if (element.hasSupportingInformationElement()) {
      composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1);
    }
  }

  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "AdverseEvent", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "AdverseEvent", "status", element.getStatusElement(), -1);
    }
    if (element.hasActualityElement()) {
      composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "AdverseEvent", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "AdverseEvent", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasDetectedElement()) {
      composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1);
    }
    if (element.hasRecordedDateElement()) {
      composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1);
    }
    for (int i = 0; i < element.getResultingEffect().size(); i++) {
      composeReference(t, "AdverseEvent", "resultingEffect", element.getResultingEffect().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
    }
    if (element.hasSeriousness()) {
      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
    }
    for (int i = 0; i < element.getOutcome().size(); i++) {
      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome().get(i), i);
    }
    if (element.hasRecorder()) {
      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeAdverseEventParticipantComponent(t, "AdverseEvent", "participant", element.getParticipant().get(i), i);
    }
    for (int i = 0; i < element.getStudy().size(); i++) {
      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
    }
    if (element.hasExpectedInResearchStudyElement()) {
      composeBoolean(t, "AdverseEvent", "expectedInResearchStudy", element.getExpectedInResearchStudyElement(), -1);
    }
    for (int i = 0; i < element.getSuspectEntity().size(); i++) {
      composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
    }
    for (int i = 0; i < element.getContributingFactor().size(); i++) {
      composeAdverseEventContributingFactorComponent(t, "AdverseEvent", "contributingFactor", element.getContributingFactor().get(i), i);
    }
    for (int i = 0; i < element.getPreventiveAction().size(); i++) {
      composeAdverseEventPreventiveActionComponent(t, "AdverseEvent", "preventiveAction", element.getPreventiveAction().get(i), i);
    }
    for (int i = 0; i < element.getMitigatingAction().size(); i++) {
      composeAdverseEventMitigatingActionComponent(t, "AdverseEvent", "mitigatingAction", element.getMitigatingAction().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeAdverseEventSupportingInfoComponent(t, "AdverseEvent", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "AdverseEvent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeAdverseEventParticipantComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    if (element.hasFunction()) {
      composeCodeableConcept(t, "AdverseEventParticipantComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "AdverseEventParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "suspectEntity", name, element, index);
    if (element.hasInstance()) {
      composeType(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1);
    }
    if (element.hasCausality()) {
      composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality(), -1);
    }
  }

  protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "causality", name, element, index);
    if (element.hasAssessmentMethod()) {
      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessmentMethod", element.getAssessmentMethod(), -1);
    }
    if (element.hasEntityRelatedness()) {
      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "entityRelatedness", element.getEntityRelatedness(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1);
    }
  }

  protected void composeAdverseEventContributingFactorComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventContributingFactorComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "contributingFactor", name, element, index);
    if (element.hasItem()) {
      composeType(t, "AdverseEventContributingFactorComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeAdverseEventPreventiveActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventPreventiveActionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "preventiveAction", name, element, index);
    if (element.hasItem()) {
      composeType(t, "AdverseEventPreventiveActionComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeAdverseEventMitigatingActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventMitigatingActionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "mitigatingAction", name, element, index);
    if (element.hasItem()) {
      composeType(t, "AdverseEventMitigatingActionComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeAdverseEventSupportingInfoComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSupportingInfoComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "supportingInfo", name, element, index);
    if (element.hasItem()) {
      composeType(t, "AdverseEventSupportingInfoComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "AllergyIntolerance", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasClinicalStatus()) {
      composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1);
    }
    if (element.hasVerificationStatus()) {
      composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "AllergyIntolerance", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
    }
    if (element.hasCriticalityElement()) {
      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOnset()) {
      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
    }
    if (element.hasRecordedDateElement()) {
      composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeAllergyIntoleranceParticipantComponent(t, "AllergyIntolerance", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasLastOccurrenceElement()) {
      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getReaction().size(); i++) {
      composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
    }
  }

  protected void composeAllergyIntoleranceParticipantComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    if (element.hasFunction()) {
      composeCodeableConcept(t, "AllergyIntoleranceParticipantComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "AllergyIntoleranceParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "reaction", name, element, index);
    if (element.hasSubstance()) {
      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1);
    }
    for (int i = 0; i < element.getManifestation().size(); i++) {
      composeCodeableReference(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasOnsetElement()) {
      composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1);
    }
    if (element.hasSeverityElement()) {
      composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1);
    }
    if (element.hasExposureRoute()) {
      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Appointment", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
    }
    if (element.hasCancellationReason()) {
      composeCodeableConcept(t, "Appointment", "cancellationReason", element.getCancellationReason(), -1);
    }
    for (int i = 0; i < element.getClass_().size(); i++) {
      composeCodeableConcept(t, "Appointment", "class", element.getClass_().get(i), i);
    }
    for (int i = 0; i < element.getServiceCategory().size(); i++) {
      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i);
    }
    for (int i = 0; i < element.getServiceType().size(); i++) {
      composeCodeableReference(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
    }
    if (element.hasAppointmentType()) {
      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "Appointment", "reason", element.getReason().get(i), i);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "Appointment", "priority", element.getPriority(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "Appointment", "replaces", element.getReplaces().get(i), i);
    }
    for (int i = 0; i < element.getVirtualService().size(); i++) {
      composeVirtualServiceDetail(t, "Appointment", "virtualService", element.getVirtualService().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    if (element.hasPreviousAppointment()) {
      composeReference(t, "Appointment", "previousAppointment", element.getPreviousAppointment(), -1);
    }
    if (element.hasOriginatingAppointment()) {
      composeReference(t, "Appointment", "originatingAppointment", element.getOriginatingAppointment(), -1);
    }
    if (element.hasStartElement()) {
      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
    }
    if (element.hasEndElement()) {
      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
    }
    if (element.hasMinutesDurationElement()) {
      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
    }
    for (int i = 0; i < element.getRequestedPeriod().size(); i++) {
      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
    }
    for (int i = 0; i < element.getSlot().size(); i++) {
      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
    }
    for (int i = 0; i < element.getAccount().size(); i++) {
      composeReference(t, "Appointment", "account", element.getAccount().get(i), i);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
    }
    if (element.hasCancellationDateElement()) {
      composeDateTime(t, "Appointment", "cancellationDate", element.getCancellationDateElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Appointment", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getPatientInstruction().size(); i++) {
      composeCodeableReference(t, "Appointment", "patientInstruction", element.getPatientInstruction().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "Appointment", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasRecurrenceIdElement()) {
      composePositiveInt(t, "Appointment", "recurrenceId", element.getRecurrenceIdElement(), -1);
    }
    if (element.hasOccurrenceChangedElement()) {
      composeBoolean(t, "Appointment", "occurrenceChanged", element.getOccurrenceChangedElement(), -1);
    }
    for (int i = 0; i < element.getRecurrenceTemplate().size(); i++) {
      composeAppointmentRecurrenceTemplateComponent(t, "Appointment", "recurrenceTemplate", element.getRecurrenceTemplate().get(i), i);
    }
  }

  protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1);
    }
    if (element.hasRequiredElement()) {
      composeBoolean(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1);
    }
  }

  protected void composeAppointmentRecurrenceTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "recurrenceTemplate", name, element, index);
    if (element.hasTimezone()) {
      composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "timezone", element.getTimezone(), -1);
    }
    if (element.hasRecurrenceType()) {
      composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "recurrenceType", element.getRecurrenceType(), -1);
    }
    if (element.hasLastOccurrenceDateElement()) {
      composeDate(t, "AppointmentRecurrenceTemplateComponent", "lastOccurrenceDate", element.getLastOccurrenceDateElement(), -1);
    }
    if (element.hasOccurrenceCountElement()) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "occurrenceCount", element.getOccurrenceCountElement(), -1);
    }
    for (int i = 0; i < element.getOccurrenceDate().size(); i++) {
      composeDate(t, "AppointmentRecurrenceTemplateComponent", "occurrenceDate", element.getOccurrenceDate().get(i), i);
    }
    if (element.hasWeeklyTemplate()) {
      composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "weeklyTemplate", element.getWeeklyTemplate(), -1);
    }
    if (element.hasMonthlyTemplate()) {
      composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "monthlyTemplate", element.getMonthlyTemplate(), -1);
    }
    if (element.hasYearlyTemplate()) {
      composeAppointmentRecurrenceTemplateYearlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "yearlyTemplate", element.getYearlyTemplate(), -1);
    }
    for (int i = 0; i < element.getExcludingDate().size(); i++) {
      composeDate(t, "AppointmentRecurrenceTemplateComponent", "excludingDate", element.getExcludingDate().get(i), i);
    }
    for (int i = 0; i < element.getExcludingRecurrenceId().size(); i++) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "excludingRecurrenceId", element.getExcludingRecurrenceId().get(i), i);
    }
  }

  protected void composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "weeklyTemplate", name, element, index);
    if (element.hasMondayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "monday", element.getMondayElement(), -1);
    }
    if (element.hasTuesdayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "tuesday", element.getTuesdayElement(), -1);
    }
    if (element.hasWednesdayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "wednesday", element.getWednesdayElement(), -1);
    }
    if (element.hasThursdayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "thursday", element.getThursdayElement(), -1);
    }
    if (element.hasFridayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "friday", element.getFridayElement(), -1);
    }
    if (element.hasSaturdayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "saturday", element.getSaturdayElement(), -1);
    }
    if (element.hasSundayElement()) {
      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "sunday", element.getSundayElement(), -1);
    }
    if (element.hasWeekIntervalElement()) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "weekInterval", element.getWeekIntervalElement(), -1);
    }
  }

  protected void composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "monthlyTemplate", name, element, index);
    if (element.hasDayOfMonthElement()) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfMonth", element.getDayOfMonthElement(), -1);
    }
    if (element.hasNthWeekOfMonth()) {
      composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "nthWeekOfMonth", element.getNthWeekOfMonth(), -1);
    }
    if (element.hasDayOfWeek()) {
      composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfWeek", element.getDayOfWeek(), -1);
    }
    if (element.hasMonthIntervalElement()) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "monthInterval", element.getMonthIntervalElement(), -1);
    }
  }

  protected void composeAppointmentRecurrenceTemplateYearlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "yearlyTemplate", name, element, index);
    if (element.hasYearIntervalElement()) {
      composePositiveInt(t, "AppointmentRecurrenceTemplateYearlyTemplateComponent", "yearInterval", element.getYearIntervalElement(), -1);
    }
  }

  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "AppointmentResponse", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasAppointment()) {
      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
    }
    if (element.hasProposedNewTimeElement()) {
      composeBoolean(t, "AppointmentResponse", "proposedNewTime", element.getProposedNewTimeElement(), -1);
    }
    if (element.hasStartElement()) {
      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
    }
    if (element.hasEndElement()) {
      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
    }
    for (int i = 0; i < element.getParticipantType().size(); i++) {
      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
    }
    if (element.hasActor()) {
      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
    }
    if (element.hasParticipantStatusElement()) {
      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
    }
    if (element.hasRecurringElement()) {
      composeBoolean(t, "AppointmentResponse", "recurring", element.getRecurringElement(), -1);
    }
    if (element.hasOccurrenceDateElement()) {
      composeDate(t, "AppointmentResponse", "occurrenceDate", element.getOccurrenceDateElement(), -1);
    }
    if (element.hasRecurrenceIdElement()) {
      composePositiveInt(t, "AppointmentResponse", "recurrenceId", element.getRecurrenceIdElement(), -1);
    }
  }

  protected void composeArtifactAssessment(Complex parent, String parentType, String name, ArtifactAssessment element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "ArtifactAssessment", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ArtifactAssessment", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ArtifactAssessment", "title", element.getTitleElement(), -1);
    }
    if (element.hasCiteAs()) {
      composeType(t, "ArtifactAssessment", "citeAs", element.getCiteAs(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ArtifactAssessment", "date", element.getDateElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ArtifactAssessment", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ArtifactAssessment", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ArtifactAssessment", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasArtifact()) {
      composeType(t, "ArtifactAssessment", "artifact", element.getArtifact(), -1);
    }
    for (int i = 0; i < element.getContent().size(); i++) {
      composeArtifactAssessmentContentComponent(t, "ArtifactAssessment", "content", element.getContent().get(i), i);
    }
    if (element.hasWorkflowStatusElement()) {
      composeEnum(t, "ArtifactAssessment", "workflowStatus", element.getWorkflowStatusElement(), -1);
    }
    if (element.hasDispositionElement()) {
      composeEnum(t, "ArtifactAssessment", "disposition", element.getDispositionElement(), -1);
    }
  }

  protected void composeArtifactAssessmentContentComponent(Complex parent, String parentType, String name, ArtifactAssessment.ArtifactAssessmentContentComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "content", name, element, index);
    if (element.hasInformationTypeElement()) {
      composeEnum(t, "ArtifactAssessmentContentComponent", "informationType", element.getInformationTypeElement(), -1);
    }
    if (element.hasSummaryElement()) {
      composeMarkdown(t, "ArtifactAssessmentContentComponent", "summary", element.getSummaryElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "classifier", element.getClassifier().get(i), i);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "ArtifactAssessmentContentComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "ArtifactAssessmentContentComponent", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getPath().size(); i++) {
      composeUri(t, "ArtifactAssessmentContentComponent", "path", element.getPath().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "ArtifactAssessmentContentComponent", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasFreeToShareElement()) {
      composeBoolean(t, "ArtifactAssessmentContentComponent", "freeToShare", element.getFreeToShareElement(), -1);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeArtifactAssessmentContentComponent(t, "ArtifactAssessmentContentComponent", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "AuditEvent", name, element, index);
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "AuditEvent", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "AuditEvent", "code", element.getCode(), -1);
    }
    if (element.hasActionElement()) {
      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
    }
    if (element.hasSeverityElement()) {
      composeEnum(t, "AuditEvent", "severity", element.getSeverityElement(), -1);
    }
    if (element.hasOccurred()) {
      composeType(t, "AuditEvent", "occurred", element.getOccurred(), -1);
    }
    if (element.hasRecordedElement()) {
      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
    }
    if (element.hasOutcome()) {
      composeAuditEventOutcomeComponent(t, "AuditEvent", "outcome", element.getOutcome(), -1);
    }
    for (int i = 0; i < element.getAuthorization().size(); i++) {
      composeCodeableConcept(t, "AuditEvent", "authorization", element.getAuthorization().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "AuditEvent", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "AuditEvent", "patient", element.getPatient(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "AuditEvent", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getAgent().size(); i++) {
      composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
    }
    if (element.hasSource()) {
      composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
    }
    for (int i = 0; i < element.getEntity().size(); i++) {
      composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
    }
  }

  protected void composeAuditEventOutcomeComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventOutcomeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "outcome", name, element, index);
    if (element.hasCode()) {
      composeCoding(t, "AuditEventOutcomeComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeCodeableConcept(t, "AuditEventOutcomeComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "agent", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getRole().size(); i++) {
      composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i);
    }
    if (element.hasWho()) {
      composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1);
    }
    if (element.hasRequestorElement()) {
      composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getPolicy().size(); i++) {
      composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i);
    }
    if (element.hasNetwork()) {
      composeType(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1);
    }
    for (int i = 0; i < element.getAuthorization().size(); i++) {
      composeCodeableConcept(t, "AuditEventAgentComponent", "authorization", element.getAuthorization().get(i), i);
    }
  }

  protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "source", name, element, index);
    if (element.hasSite()) {
      composeReference(t, "AuditEventSourceComponent", "site", element.getSite(), -1);
    }
    if (element.hasObserver()) {
      composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "AuditEventSourceComponent", "type", element.getType().get(i), i);
    }
  }

  protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "entity", name, element, index);
    if (element.hasWhat()) {
      composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "AuditEventEntityComponent", "role", element.getRole(), -1);
    }
    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
      composeCodeableConcept(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i);
    }
    if (element.hasQueryElement()) {
      composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i);
    }
    for (int i = 0; i < element.getAgent().size(); i++) {
      composeAuditEventAgentComponent(t, "AuditEventEntityComponent", "agent", element.getAgent().get(i), i);
    }
  }

  protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "detail", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "AuditEventEntityDetailComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Basic", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Basic", "subject", element.getSubject(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "Basic", "created", element.getCreatedElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "Basic", "author", element.getAuthor(), -1);
    }
  }

  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeResource(t, "Binary", name, element, index);
    if (element.hasContentTypeElement()) {
      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
    }
    if (element.hasSecurityContext()) {
      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
    }
    if (element.hasDataElement()) {
      composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1);
    }
  }

  protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index);
    if (element.hasProductCategory()) {
      composeCoding(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategory(), -1);
    }
    if (element.hasProductCode()) {
      composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1);
    }
    for (int i = 0; i < element.getParent().size(); i++) {
      composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i);
    }
    for (int i = 0; i < element.getRequest().size(); i++) {
      composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasBiologicalSourceEvent()) {
      composeIdentifier(t, "BiologicallyDerivedProduct", "biologicalSourceEvent", element.getBiologicalSourceEvent(), -1);
    }
    for (int i = 0; i < element.getProcessingFacility().size(); i++) {
      composeReference(t, "BiologicallyDerivedProduct", "processingFacility", element.getProcessingFacility().get(i), i);
    }
    if (element.hasDivisionElement()) {
      composeString(t, "BiologicallyDerivedProduct", "division", element.getDivisionElement(), -1);
    }
    if (element.hasProductStatus()) {
      composeCoding(t, "BiologicallyDerivedProduct", "productStatus", element.getProductStatus(), -1);
    }
    if (element.hasExpirationDateElement()) {
      composeDateTime(t, "BiologicallyDerivedProduct", "expirationDate", element.getExpirationDateElement(), -1);
    }
    if (element.hasCollection()) {
      composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1);
    }
    if (element.hasStorageTempRequirements()) {
      composeRange(t, "BiologicallyDerivedProduct", "storageTempRequirements", element.getStorageTempRequirements(), -1);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeBiologicallyDerivedProductPropertyComponent(t, "BiologicallyDerivedProduct", "property", element.getProperty().get(i), i);
    }
  }

  protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "collection", name, element, index);
    if (element.hasCollector()) {
      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1);
    }
    if (element.hasSource()) {
      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1);
    }
    if (element.hasCollected()) {
      composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1);
    }
  }

  protected void composeBiologicallyDerivedProductPropertyComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "BiologicallyDerivedProductPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "BiologicallyDerivedProductPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeBiologicallyDerivedProductDispense(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "BiologicallyDerivedProductDispense", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "BiologicallyDerivedProductDispense", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "BiologicallyDerivedProductDispense", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "BiologicallyDerivedProductDispense", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "BiologicallyDerivedProductDispense", "status", element.getStatusElement(), -1);
    }
    if (element.hasOriginRelationshipType()) {
      composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "originRelationshipType", element.getOriginRelationshipType(), -1);
    }
    if (element.hasProduct()) {
      composeReference(t, "BiologicallyDerivedProductDispense", "product", element.getProduct(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "BiologicallyDerivedProductDispense", "patient", element.getPatient(), -1);
    }
    if (element.hasMatchStatus()) {
      composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "matchStatus", element.getMatchStatus(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeBiologicallyDerivedProductDispensePerformerComponent(t, "BiologicallyDerivedProductDispense", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "BiologicallyDerivedProductDispense", "location", element.getLocation(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "BiologicallyDerivedProductDispense", "quantity", element.getQuantity(), -1);
    }
    if (element.hasPreparedDateElement()) {
      composeDateTime(t, "BiologicallyDerivedProductDispense", "preparedDate", element.getPreparedDateElement(), -1);
    }
    if (element.hasWhenHandedOverElement()) {
      composeDateTime(t, "BiologicallyDerivedProductDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
    }
    if (element.hasDestination()) {
      composeReference(t, "BiologicallyDerivedProductDispense", "destination", element.getDestination(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "BiologicallyDerivedProductDispense", "note", element.getNote().get(i), i);
    }
    if (element.hasUsageInstructionElement()) {
      composeString(t, "BiologicallyDerivedProductDispense", "usageInstruction", element.getUsageInstructionElement(), -1);
    }
  }

  protected void composeBiologicallyDerivedProductDispensePerformerComponent(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense.BiologicallyDerivedProductDispensePerformerComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "performer", name, element, index);
    if (element.hasFunction()) {
      composeCodeableConcept(t, "BiologicallyDerivedProductDispensePerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "BiologicallyDerivedProductDispensePerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "BodyStructure", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1);
    }
    if (element.hasMorphology()) {
      composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1);
    }
    for (int i = 0; i < element.getIncludedStructure().size(); i++) {
      composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "includedStructure", element.getIncludedStructure().get(i), i);
    }
    for (int i = 0; i < element.getExcludedStructure().size(); i++) {
      composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "excludedStructure", element.getExcludedStructure().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "BodyStructure", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getImage().size(); i++) {
      composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "BodyStructure", "patient", element.getPatient(), -1);
    }
  }

  protected void composeBodyStructureIncludedStructureComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "includedStructure", name, element, index);
    if (element.hasStructure()) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "structure", element.getStructure(), -1);
    }
    if (element.hasLaterality()) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "laterality", element.getLaterality(), -1);
    }
    for (int i = 0; i < element.getBodyLandmarkOrientation().size(); i++) {
      composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(t, "BodyStructureIncludedStructureComponent", "bodyLandmarkOrientation", element.getBodyLandmarkOrientation().get(i), i);
    }
    for (int i = 0; i < element.getSpatialReference().size(); i++) {
      composeReference(t, "BodyStructureIncludedStructureComponent", "spatialReference", element.getSpatialReference().get(i), i);
    }
    for (int i = 0; i < element.getQualifier().size(); i++) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "qualifier", element.getQualifier().get(i), i);
    }
  }

  protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "bodyLandmarkOrientation", name, element, index);
    for (int i = 0; i < element.getLandmarkDescription().size(); i++) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "landmarkDescription", element.getLandmarkDescription().get(i), i);
    }
    for (int i = 0; i < element.getClockFacePosition().size(); i++) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "clockFacePosition", element.getClockFacePosition().get(i), i);
    }
    for (int i = 0; i < element.getDistanceFromLandmark().size(); i++) {
      composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "distanceFromLandmark", element.getDistanceFromLandmark().get(i), i);
    }
    for (int i = 0; i < element.getSurfaceOrientation().size(); i++) {
      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "surfaceOrientation", element.getSurfaceOrientation().get(i), i);
    }
  }

  protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "distanceFromLandmark", name, element, index);
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeCodeableReference(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "device", element.getDevice().get(i), i);
    }
    for (int i = 0; i < element.getValue().size(); i++) {
      composeQuantity(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "value", element.getValue().get(i), i);
    }
  }

  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeResource(t, "Bundle", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
    }
    if (element.hasTimestampElement()) {
      composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1);
    }
    if (element.hasTotalElement()) {
      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
    }
    for (int i = 0; i < element.getEntry().size(); i++) {
      composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
    }
    if (element.hasSignature()) {
      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
    }
    if (element.hasIssues()) {
      composeResource(t, "Bundle", "issues", element.getIssues(), -1);
    }
  }

  protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "link", name, element, index);
    if (element.hasRelationElement()) {
      composeEnum(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "entry", name, element, index);
    for (int i = 0; i < element.getLink().size(); i++) {
      composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i);
    }
    if (element.hasFullUrlElement()) {
      composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1);
    }
    if (element.hasResource()) {
      composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1);
    }
    if (element.hasSearch()) {
      composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1);
    }
    if (element.hasRequest()) {
      composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1);
    }
    if (element.hasResponse()) {
      composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1);
    }
  }

  protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "search", name, element, index);
    if (element.hasModeElement()) {
      composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasScoreElement()) {
      composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1);
    }
  }

  protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "request", name, element, index);
    if (element.hasMethodElement()) {
      composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1);
    }
    if (element.hasIfNoneMatchElement()) {
      composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
    }
    if (element.hasIfModifiedSinceElement()) {
      composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
    }
    if (element.hasIfMatchElement()) {
      composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1);
    }
    if (element.hasIfNoneExistElement()) {
      composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1);
    }
  }

  protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "response", name, element, index);
    if (element.hasStatusElement()) {
      composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1);
    }
    if (element.hasLocationElement()) {
      composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1);
    }
    if (element.hasEtagElement()) {
      composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1);
    }
    if (element.hasLastModifiedElement()) {
      composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1);
    }
    if (element.hasOutcome()) {
      composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1);
    }
  }

  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeCanonicalResource(t, "CapabilityStatement", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CapabilityStatement", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "CapabilityStatement", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "CapabilityStatement", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
    }
    for (int i = 0; i < element.getInstantiates().size(); i++) {
      composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
    }
    for (int i = 0; i < element.getImports().size(); i++) {
      composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i);
    }
    if (element.hasSoftware()) {
      composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
    }
    if (element.hasImplementation()) {
      composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
    }
    if (element.hasFhirVersionElement()) {
      composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
    }
    for (int i = 0; i < element.getFormat().size(); i++) {
      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
    }
    for (int i = 0; i < element.getPatchFormat().size(); i++) {
      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
    }
    for (int i = 0; i < element.getAcceptLanguage().size(); i++) {
      composeCode(t, "CapabilityStatement", "acceptLanguage", element.getAcceptLanguage().get(i), i);
    }
    for (int i = 0; i < element.getImplementationGuide().size(); i++) {
      composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
    }
    for (int i = 0; i < element.getRest().size(); i++) {
      composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
    }
    for (int i = 0; i < element.getMessaging().size(); i++) {
      composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
    }
    for (int i = 0; i < element.getDocument().size(); i++) {
      composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
    }
  }

  protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "software", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1);
    }
    if (element.hasReleaseDateElement()) {
      composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1);
    }
  }

  protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "implementation", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1);
    }
    if (element.hasCustodian()) {
      composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1);
    }
  }

  protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "rest", name, element, index);
    if (element.hasModeElement()) {
      composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasSecurity()) {
      composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1);
    }
    for (int i = 0; i < element.getResource().size(); i++) {
      composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i);
    }
    for (int i = 0; i < element.getInteraction().size(); i++) {
      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i);
    }
    for (int i = 0; i < element.getSearchParam().size(); i++) {
      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i);
    }
    for (int i = 0; i < element.getOperation().size(); i++) {
      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i);
    }
    for (int i = 0; i < element.getCompartment().size(); i++) {
      composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i);
    }
  }

  protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "security", name, element, index);
    if (element.hasCorsElement()) {
      composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1);
    }
    for (int i = 0; i < element.getService().size(); i++) {
      composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "resource", name, element, index);
    if (element.hasTypeElement()) {
      composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1);
    }
    for (int i = 0; i < element.getSupportedProfile().size(); i++) {
      composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1);
    }
    for (int i = 0; i < element.getInteraction().size(); i++) {
      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i);
    }
    if (element.hasVersioningElement()) {
      composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1);
    }
    if (element.hasReadHistoryElement()) {
      composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1);
    }
    if (element.hasUpdateCreateElement()) {
      composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1);
    }
    if (element.hasConditionalCreateElement()) {
      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1);
    }
    if (element.hasConditionalReadElement()) {
      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1);
    }
    if (element.hasConditionalUpdateElement()) {
      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
    }
    if (element.hasConditionalPatchElement()) {
      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalPatch", element.getConditionalPatchElement(), -1);
    }
    if (element.hasConditionalDeleteElement()) {
      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1);
    }
    for (int i = 0; i < element.getReferencePolicy().size(); i++) {
      composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i);
    }
    for (int i = 0; i < element.getSearchInclude().size(); i++) {
      composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i);
    }
    for (int i = 0; i < element.getSearchRevInclude().size(); i++) {
      composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i);
    }
    for (int i = 0; i < element.getSearchParam().size(); i++) {
      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i);
    }
    for (int i = 0; i < element.getOperation().size(); i++) {
      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i);
    }
  }

  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "interaction", name, element, index);
    if (element.hasCodeElement()) {
      composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "searchParam", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "operation", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "interaction", name, element, index);
    if (element.hasCodeElement()) {
      composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "messaging", name, element, index);
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i);
    }
    if (element.hasReliableCacheElement()) {
      composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1);
    }
    for (int i = 0; i < element.getSupportedMessage().size(); i++) {
      composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i);
    }
  }

  protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "endpoint", name, element, index);
    if (element.hasProtocol()) {
      composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1);
    }
    if (element.hasAddressElement()) {
      composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1);
    }
  }

  protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "supportedMessage", name, element, index);
    if (element.hasModeElement()) {
      composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1);
    }
  }

  protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "document", name, element, index);
    if (element.hasModeElement()) {
      composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1);
    }
  }

  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "CarePlan", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1);
    }
    if (element.hasCustodian()) {
      composeReference(t, "CarePlan", "custodian", element.getCustodian(), -1);
    }
    for (int i = 0; i < element.getContributor().size(); i++) {
      composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i);
    }
    for (int i = 0; i < element.getCareTeam().size(); i++) {
      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
    }
    for (int i = 0; i < element.getAddresses().size(); i++) {
      composeCodeableReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getGoal().size(); i++) {
      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
    }
    for (int i = 0; i < element.getActivity().size(); i++) {
      composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
    }
  }

  protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "activity", name, element, index);
    for (int i = 0; i < element.getPerformedActivity().size(); i++) {
      composeCodeableReference(t, "CarePlanActivityComponent", "performedActivity", element.getPerformedActivity().get(i), i);
    }
    for (int i = 0; i < element.getProgress().size(); i++) {
      composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i);
    }
    if (element.hasPlannedActivityReference()) {
      composeReference(t, "CarePlanActivityComponent", "plannedActivityReference", element.getPlannedActivityReference(), -1);
    }
  }

  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "CareTeam", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "CareTeam", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getManagingOrganization().size(); i++) {
      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
    }
  }

  protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    if (element.hasRole()) {
      composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole(), -1);
    }
    if (element.hasMember()) {
      composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1);
    }
    if (element.hasOnBehalfOf()) {
      composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
    }
    if (element.hasCoverage()) {
      composeType(t, "CareTeamParticipantComponent", "coverage", element.getCoverage(), -1);
    }
  }

  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "ChargeItem", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getDefinitionUri().size(); i++) {
      composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i);
    }
    for (int i = 0; i < element.getDefinitionCanonical().size(); i++) {
      composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "ChargeItem", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasPerformingOrganization()) {
      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
    }
    if (element.hasRequestingOrganization()) {
      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
    }
    if (element.hasCostCenter()) {
      composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
    }
    for (int i = 0; i < element.getBodysite().size(); i++) {
      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
    }
    if (element.hasUnitPriceComponent()) {
      composeMonetaryComponent(t, "ChargeItem", "unitPriceComponent", element.getUnitPriceComponent(), -1);
    }
    if (element.hasTotalPriceComponent()) {
      composeMonetaryComponent(t, "ChargeItem", "totalPriceComponent", element.getTotalPriceComponent(), -1);
    }
    if (element.hasOverrideReason()) {
      composeCodeableConcept(t, "ChargeItem", "overrideReason", element.getOverrideReason(), -1);
    }
    if (element.hasEnterer()) {
      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
    }
    if (element.hasEnteredDateElement()) {
      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getService().size(); i++) {
      composeCodeableReference(t, "ChargeItem", "service", element.getService().get(i), i);
    }
    for (int i = 0; i < element.getProduct().size(); i++) {
      composeCodeableReference(t, "ChargeItem", "product", element.getProduct().get(i), i);
    }
    for (int i = 0; i < element.getAccount().size(); i++) {
      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
  }

  protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "performer", name, element, index);
    if (element.hasFunction()) {
      composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "ChargeItemDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ChargeItemDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ChargeItemDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
      composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ChargeItemDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ChargeItemDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getInstance().size(); i++) {
      composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i);
    }
    for (int i = 0; i < element.getApplicability().size(); i++) {
      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
    }
    for (int i = 0; i < element.getPropertyGroup().size(); i++) {
      composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i);
    }
  }

  protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "applicability", name, element, index);
    if (element.hasCondition()) {
      composeExpression(t, "ChargeItemDefinitionApplicabilityComponent", "condition", element.getCondition(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "ChargeItemDefinitionApplicabilityComponent", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    if (element.hasRelatedArtifact()) {
      composeRelatedArtifact(t, "ChargeItemDefinitionApplicabilityComponent", "relatedArtifact", element.getRelatedArtifact(), -1);
    }
  }

  protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "propertyGroup", name, element, index);
    for (int i = 0; i < element.getApplicability().size(); i++) {
      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i);
    }
    for (int i = 0; i < element.getPriceComponent().size(); i++) {
      composeMonetaryComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i);
    }
  }

  protected void composeCitation(Complex parent, String parentType, String name, Citation element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "Citation", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Citation", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Citation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Citation", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Citation", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Citation", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Citation", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Citation", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Citation", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Citation", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Citation", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Citation", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Citation", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Citation", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "Citation", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Citation", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Citation", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Citation", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "Citation", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "Citation", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "Citation", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "Citation", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "Citation", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "Citation", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "Citation", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getSummary().size(); i++) {
      composeCitationSummaryComponent(t, "Citation", "summary", element.getSummary().get(i), i);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeCitationClassificationComponent(t, "Citation", "classification", element.getClassification().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Citation", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getCurrentState().size(); i++) {
      composeCodeableConcept(t, "Citation", "currentState", element.getCurrentState().get(i), i);
    }
    for (int i = 0; i < element.getStatusDate().size(); i++) {
      composeCitationStatusDateComponent(t, "Citation", "statusDate", element.getStatusDate().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "Citation", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasCitedArtifact()) {
      composeCitationCitedArtifactComponent(t, "Citation", "citedArtifact", element.getCitedArtifact(), -1);
    }
  }

  protected void composeCitationSummaryComponent(Complex parent, String parentType, String name, Citation.CitationSummaryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "summary", name, element, index);
    if (element.hasStyle()) {
      composeCodeableConcept(t, "CitationSummaryComponent", "style", element.getStyle(), -1);
    }
    if (element.hasTextElement()) {
      composeMarkdown(t, "CitationSummaryComponent", "text", element.getTextElement(), -1);
    }
  }

  protected void composeCitationClassificationComponent(Complex parent, String parentType, String name, Citation.CitationClassificationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "classification", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationClassificationComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "CitationClassificationComponent", "classifier", element.getClassifier().get(i), i);
    }
  }

  protected void composeCitationStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationStatusDateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "statusDate", name, element, index);
    if (element.hasActivity()) {
      composeCodeableConcept(t, "CitationStatusDateComponent", "activity", element.getActivity(), -1);
    }
    if (element.hasActualElement()) {
      composeBoolean(t, "CitationStatusDateComponent", "actual", element.getActualElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "CitationStatusDateComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeCitationCitedArtifactComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "citedArtifact", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CitationCitedArtifactComponent", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getRelatedIdentifier().size(); i++) {
      composeIdentifier(t, "CitationCitedArtifactComponent", "relatedIdentifier", element.getRelatedIdentifier().get(i), i);
    }
    if (element.hasDateAccessedElement()) {
      composeDateTime(t, "CitationCitedArtifactComponent", "dateAccessed", element.getDateAccessedElement(), -1);
    }
    if (element.hasVersion()) {
      composeCitationCitedArtifactVersionComponent(t, "CitationCitedArtifactComponent", "version", element.getVersion(), -1);
    }
    for (int i = 0; i < element.getCurrentState().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactComponent", "currentState", element.getCurrentState().get(i), i);
    }
    for (int i = 0; i < element.getStatusDate().size(); i++) {
      composeCitationCitedArtifactStatusDateComponent(t, "CitationCitedArtifactComponent", "statusDate", element.getStatusDate().get(i), i);
    }
    for (int i = 0; i < element.getTitle().size(); i++) {
      composeCitationCitedArtifactTitleComponent(t, "CitationCitedArtifactComponent", "title", element.getTitle().get(i), i);
    }
    for (int i = 0; i < element.getAbstract().size(); i++) {
      composeCitationCitedArtifactAbstractComponent(t, "CitationCitedArtifactComponent", "abstract", element.getAbstract().get(i), i);
    }
    if (element.hasPart()) {
      composeCitationCitedArtifactPartComponent(t, "CitationCitedArtifactComponent", "part", element.getPart(), -1);
    }
    for (int i = 0; i < element.getRelatesTo().size(); i++) {
      composeCitationCitedArtifactRelatesToComponent(t, "CitationCitedArtifactComponent", "relatesTo", element.getRelatesTo().get(i), i);
    }
    for (int i = 0; i < element.getPublicationForm().size(); i++) {
      composeCitationCitedArtifactPublicationFormComponent(t, "CitationCitedArtifactComponent", "publicationForm", element.getPublicationForm().get(i), i);
    }
    for (int i = 0; i < element.getWebLocation().size(); i++) {
      composeCitationCitedArtifactWebLocationComponent(t, "CitationCitedArtifactComponent", "webLocation", element.getWebLocation().get(i), i);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeCitationCitedArtifactClassificationComponent(t, "CitationCitedArtifactComponent", "classification", element.getClassification().get(i), i);
    }
    if (element.hasContributorship()) {
      composeCitationCitedArtifactContributorshipComponent(t, "CitationCitedArtifactComponent", "contributorship", element.getContributorship(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "CitationCitedArtifactComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeCitationCitedArtifactVersionComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactVersionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "version", name, element, index);
    if (element.hasValueElement()) {
      composeString(t, "CitationCitedArtifactVersionComponent", "value", element.getValueElement(), -1);
    }
    if (element.hasBaseCitation()) {
      composeReference(t, "CitationCitedArtifactVersionComponent", "baseCitation", element.getBaseCitation(), -1);
    }
  }

  protected void composeCitationCitedArtifactStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactStatusDateComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "statusDate", name, element, index);
    if (element.hasActivity()) {
      composeCodeableConcept(t, "CitationCitedArtifactStatusDateComponent", "activity", element.getActivity(), -1);
    }
    if (element.hasActualElement()) {
      composeBoolean(t, "CitationCitedArtifactStatusDateComponent", "actual", element.getActualElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "CitationCitedArtifactStatusDateComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeCitationCitedArtifactTitleComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactTitleComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "title", name, element, index);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "type", element.getType().get(i), i);
    }
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasTextElement()) {
      composeMarkdown(t, "CitationCitedArtifactTitleComponent", "text", element.getTextElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactAbstractComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactAbstractComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "abstract", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "type", element.getType(), -1);
    }
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasTextElement()) {
      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "text", element.getTextElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "copyright", element.getCopyrightElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactPartComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPartComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "part", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationCitedArtifactPartComponent", "type", element.getType(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "CitationCitedArtifactPartComponent", "value", element.getValueElement(), -1);
    }
    if (element.hasBaseCitation()) {
      composeReference(t, "CitationCitedArtifactPartComponent", "baseCitation", element.getBaseCitation(), -1);
    }
  }

  protected void composeCitationCitedArtifactRelatesToComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactRelatesToComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "relatesTo", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "CitationCitedArtifactRelatesToComponent", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactRelatesToComponent", "classifier", element.getClassifier().get(i), i);
    }
    if (element.hasLabelElement()) {
      composeString(t, "CitationCitedArtifactRelatesToComponent", "label", element.getLabelElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "CitationCitedArtifactRelatesToComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasCitationElement()) {
      composeMarkdown(t, "CitationCitedArtifactRelatesToComponent", "citation", element.getCitationElement(), -1);
    }
    if (element.hasDocument()) {
      composeAttachment(t, "CitationCitedArtifactRelatesToComponent", "document", element.getDocument(), -1);
    }
    if (element.hasResourceElement()) {
      composeCanonical(t, "CitationCitedArtifactRelatesToComponent", "resource", element.getResourceElement(), -1);
    }
    if (element.hasResourceReference()) {
      composeReference(t, "CitationCitedArtifactRelatesToComponent", "resourceReference", element.getResourceReference(), -1);
    }
  }

  protected void composeCitationCitedArtifactPublicationFormComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "publicationForm", name, element, index);
    if (element.hasPublishedIn()) {
      composeCitationCitedArtifactPublicationFormPublishedInComponent(t, "CitationCitedArtifactPublicationFormComponent", "publishedIn", element.getPublishedIn(), -1);
    }
    if (element.hasCitedMedium()) {
      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "citedMedium", element.getCitedMedium(), -1);
    }
    if (element.hasVolumeElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "volume", element.getVolumeElement(), -1);
    }
    if (element.hasIssueElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "issue", element.getIssueElement(), -1);
    }
    if (element.hasArticleDateElement()) {
      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "articleDate", element.getArticleDateElement(), -1);
    }
    if (element.hasPublicationDateTextElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateText", element.getPublicationDateTextElement(), -1);
    }
    if (element.hasPublicationDateSeasonElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateSeason", element.getPublicationDateSeasonElement(), -1);
    }
    if (element.hasLastRevisionDateElement()) {
      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "lastRevisionDate", element.getLastRevisionDateElement(), -1);
    }
    for (int i = 0; i < element.getLanguage().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "language", element.getLanguage().get(i), i);
    }
    if (element.hasAccessionNumberElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "accessionNumber", element.getAccessionNumberElement(), -1);
    }
    if (element.hasPageStringElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageString", element.getPageStringElement(), -1);
    }
    if (element.hasFirstPageElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "firstPage", element.getFirstPageElement(), -1);
    }
    if (element.hasLastPageElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "lastPage", element.getLastPageElement(), -1);
    }
    if (element.hasPageCountElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageCount", element.getPageCountElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "CitationCitedArtifactPublicationFormComponent", "copyright", element.getCopyrightElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactPublicationFormPublishedInComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPublishedInComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "publishedIn", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasPublisher()) {
      composeReference(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisher", element.getPublisher(), -1);
    }
    if (element.hasPublisherLocationElement()) {
      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisherLocation", element.getPublisherLocationElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactWebLocationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactWebLocationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "webLocation", name, element, index);
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactWebLocationComponent", "classifier", element.getClassifier().get(i), i);
    }
    if (element.hasUrlElement()) {
      composeUri(t, "CitationCitedArtifactWebLocationComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactClassificationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactClassificationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "classification", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "classifier", element.getClassifier().get(i), i);
    }
    for (int i = 0; i < element.getArtifactAssessment().size(); i++) {
      composeReference(t, "CitationCitedArtifactClassificationComponent", "artifactAssessment", element.getArtifactAssessment().get(i), i);
    }
  }

  protected void composeCitationCitedArtifactContributorshipComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "contributorship", name, element, index);
    if (element.hasCompleteElement()) {
      composeBoolean(t, "CitationCitedArtifactContributorshipComponent", "complete", element.getCompleteElement(), -1);
    }
    for (int i = 0; i < element.getEntry().size(); i++) {
      composeCitationCitedArtifactContributorshipEntryComponent(t, "CitationCitedArtifactContributorshipComponent", "entry", element.getEntry().get(i), i);
    }
    for (int i = 0; i < element.getSummary().size(); i++) {
      composeCitationContributorshipSummaryComponent(t, "CitationCitedArtifactContributorshipComponent", "summary", element.getSummary().get(i), i);
    }
  }

  protected void composeCitationCitedArtifactContributorshipEntryComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "entry", name, element, index);
    if (element.hasContributor()) {
      composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "contributor", element.getContributor(), -1);
    }
    if (element.hasForenameInitialsElement()) {
      composeString(t, "CitationCitedArtifactContributorshipEntryComponent", "forenameInitials", element.getForenameInitialsElement(), -1);
    }
    for (int i = 0; i < element.getAffiliation().size(); i++) {
      composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "affiliation", element.getAffiliation().get(i), i);
    }
    for (int i = 0; i < element.getContributionType().size(); i++) {
      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionType", element.getContributionType().get(i), i);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "role", element.getRole(), -1);
    }
    for (int i = 0; i < element.getContributionInstance().size(); i++) {
      composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionInstance", element.getContributionInstance().get(i), i);
    }
    if (element.hasCorrespondingContactElement()) {
      composeBoolean(t, "CitationCitedArtifactContributorshipEntryComponent", "correspondingContact", element.getCorrespondingContactElement(), -1);
    }
    if (element.hasRankingOrderElement()) {
      composePositiveInt(t, "CitationCitedArtifactContributorshipEntryComponent", "rankingOrder", element.getRankingOrderElement(), -1);
    }
  }

  protected void composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "contributionInstance", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "type", element.getType(), -1);
    }
    if (element.hasTimeElement()) {
      composeDateTime(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "time", element.getTimeElement(), -1);
    }
  }

  protected void composeCitationContributorshipSummaryComponent(Complex parent, String parentType, String name, Citation.ContributorshipSummaryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "summary", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ContributorshipSummaryComponent", "type", element.getType(), -1);
    }
    if (element.hasStyle()) {
      composeCodeableConcept(t, "ContributorshipSummaryComponent", "style", element.getStyle(), -1);
    }
    if (element.hasSource()) {
      composeCodeableConcept(t, "ContributorshipSummaryComponent", "source", element.getSource(), -1);
    }
    if (element.hasValueElement()) {
      composeMarkdown(t, "ContributorshipSummaryComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Claim", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "Claim", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
    }
    if (element.hasSubType()) {
      composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "Claim", "patient", element.getPatient(), -1);
    }
    if (element.hasBillablePeriod()) {
      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
    }
    if (element.hasEnterer()) {
      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
    }
    if (element.hasProvider()) {
      composeReference(t, "Claim", "provider", element.getProvider(), -1);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
    }
    if (element.hasFundsReserve()) {
      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
    }
    for (int i = 0; i < element.getRelated().size(); i++) {
      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
    }
    if (element.hasPrescription()) {
      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
    }
    if (element.hasOriginalPrescription()) {
      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
    }
    if (element.hasPayee()) {
      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
    }
    if (element.hasReferral()) {
      composeReference(t, "Claim", "referral", element.getReferral(), -1);
    }
    for (int i = 0; i < element.getEncounter().size(); i++) {
      composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i);
    }
    if (element.hasFacility()) {
      composeReference(t, "Claim", "facility", element.getFacility(), -1);
    }
    if (element.hasDiagnosisRelatedGroup()) {
      composeCodeableConcept(t, "Claim", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeClaimEventComponent(t, "Claim", "event", element.getEvent().get(i), i);
    }
    for (int i = 0; i < element.getCareTeam().size(); i++) {
      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
    }
    for (int i = 0; i < element.getProcedure().size(); i++) {
      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
    }
    if (element.hasAccident()) {
      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "Claim", "patientPaid", element.getPatientPaid(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
    }
    if (element.hasTotal()) {
      composeMoney(t, "Claim", "total", element.getTotal(), -1);
    }
  }

  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "related", name, element, index);
    if (element.hasClaim()) {
      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
    }
    if (element.hasRelationship()) {
      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
    }
    if (element.hasReference()) {
      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "payee", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
    }
    if (element.hasParty()) {
      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
    }
  }

  protected void composeClaimEventComponent(Complex parent, String parentType, String name, Claim.ClaimEventComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "event", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ClaimEventComponent", "type", element.getType(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "ClaimEventComponent", "when", element.getWhen(), -1);
    }
  }

  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "careTeam", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasProvider()) {
      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
    }
    if (element.hasResponsibleElement()) {
      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
    }
    if (element.hasSpecialty()) {
      composeCodeableConcept(t, "CareTeamComponent", "specialty", element.getSpecialty(), -1);
    }
  }

  protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "supportingInfo", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
    }
    if (element.hasTiming()) {
      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
    }
  }

  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "diagnosis", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasDiagnosis()) {
      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
    }
    if (element.hasOnAdmission()) {
      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
    }
  }

  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "procedure", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasProcedure()) {
      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
    }
    for (int i = 0; i < element.getUdi().size(); i++) {
      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
    }
  }

  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "insurance", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasFocalElement()) {
      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasCoverage()) {
      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
    }
    if (element.hasBusinessArrangementElement()) {
      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
    }
    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
    }
    if (element.hasClaimResponse()) {
      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
    }
  }

  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "accident", name, element, index);
    if (element.hasDateElement()) {
      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
    }
    if (element.hasLocation()) {
      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
    }
  }

  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "item", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
    }
    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
    }
    for (int i = 0; i < element.getInformationSequence().size(); i++) {
      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "ItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getRequest().size(); i++) {
      composeReference(t, "ItemComponent", "request", element.getRequest().get(i), i);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
    }
    for (int i = 0; i < element.getProgramCode().size(); i++) {
      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
    }
    if (element.hasServiced()) {
      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
    }
    if (element.hasLocation()) {
      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "ItemComponent", "patientPaid", element.getPatientPaid(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "ItemComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getUdi().size(); i++) {
      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeClaimBodySiteComponent(t, "ItemComponent", "bodySite", element.getBodySite().get(i), i);
    }
    for (int i = 0; i < element.getEncounter().size(); i++) {
      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeClaimBodySiteComponent(Complex parent, String parentType, String name, Claim.BodySiteComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "bodySite", name, element, index);
    for (int i = 0; i < element.getSite().size(); i++) {
      composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i);
    }
    for (int i = 0; i < element.getSubSite().size(); i++) {
      composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i);
    }
  }

  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "detail", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "DetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "DetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
    }
    for (int i = 0; i < element.getProgramCode().size(); i++) {
      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "DetailComponent", "patientPaid", element.getPatientPaid(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "DetailComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getUdi().size(); i++) {
      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
    }
    for (int i = 0; i < element.getSubDetail().size(); i++) {
      composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
    }
  }

  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "subDetail", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "SubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
    }
    for (int i = 0; i < element.getProgramCode().size(); i++) {
      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "SubDetailComponent", "patientPaid", element.getPatientPaid(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "SubDetailComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getUdi().size(); i++) {
      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
    }
  }

  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "ClaimResponse", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ClaimResponse", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
    }
    if (element.hasSubType()) {
      composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
    }
    if (element.hasRequestor()) {
      composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1);
    }
    if (element.hasRequest()) {
      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
    }
    if (element.hasOutcomeElement()) {
      composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1);
    }
    if (element.hasDecision()) {
      composeCodeableConcept(t, "ClaimResponse", "decision", element.getDecision(), -1);
    }
    if (element.hasDispositionElement()) {
      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
    }
    if (element.hasPreAuthRefElement()) {
      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
    }
    if (element.hasPreAuthPeriod()) {
      composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeClaimResponseEventComponent(t, "ClaimResponse", "event", element.getEvent().get(i), i);
    }
    if (element.hasPayeeType()) {
      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
    }
    for (int i = 0; i < element.getEncounter().size(); i++) {
      composeReference(t, "ClaimResponse", "encounter", element.getEncounter().get(i), i);
    }
    if (element.hasDiagnosisRelatedGroup()) {
      composeCodeableConcept(t, "ClaimResponse", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
    }
    for (int i = 0; i < element.getAddItem().size(); i++) {
      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getTotal().size(); i++) {
      composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i);
    }
    if (element.hasPayment()) {
      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
    }
    if (element.hasFundsReserve()) {
      composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1);
    }
    if (element.hasFormCode()) {
      composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1);
    }
    if (element.hasForm()) {
      composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1);
    }
    for (int i = 0; i < element.getProcessNote().size(); i++) {
      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
    }
    for (int i = 0; i < element.getCommunicationRequest().size(); i++) {
      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getError().size(); i++) {
      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
    }
  }

  protected void composeClaimResponseEventComponent(Complex parent, String parentType, String name, ClaimResponse.ClaimResponseEventComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "event", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ClaimResponseEventComponent", "type", element.getType(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "ClaimResponseEventComponent", "when", element.getWhen(), -1);
    }
  }

  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "item", name, element, index);
    if (element.hasItemSequenceElement()) {
      composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "ItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeClaimResponseReviewOutcomeComponent(Complex parent, String parentType, String name, ClaimResponse.ReviewOutcomeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "reviewOutcome", name, element, index);
    if (element.hasDecision()) {
      composeCodeableConcept(t, "ReviewOutcomeComponent", "decision", element.getDecision(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "ReviewOutcomeComponent", "reason", element.getReason().get(i), i);
    }
    if (element.hasPreAuthRefElement()) {
      composeString(t, "ReviewOutcomeComponent", "preAuthRef", element.getPreAuthRefElement(), -1);
    }
    if (element.hasPreAuthPeriod()) {
      composePeriod(t, "ReviewOutcomeComponent", "preAuthPeriod", element.getPreAuthPeriod(), -1);
    }
  }

  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "adjudication", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "AdjudicationComponent", "quantity", element.getQuantity(), -1);
    }
  }

  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "detail", name, element, index);
    if (element.hasDetailSequenceElement()) {
      composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "ItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getSubDetail().size(); i++) {
      composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
    }
  }

  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "subDetail", name, element, index);
    if (element.hasSubDetailSequenceElement()) {
      composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "SubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
  }

  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "addItem", name, element, index);
    for (int i = 0; i < element.getItemSequence().size(); i++) {
      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
    }
    for (int i = 0; i < element.getDetailSequence().size(); i++) {
      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
    }
    for (int i = 0; i < element.getSubdetailSequence().size(); i++) {
      composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "AddedItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    for (int i = 0; i < element.getProvider().size(); i++) {
      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "AddedItemComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "AddedItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getRequest().size(); i++) {
      composeReference(t, "AddedItemComponent", "request", element.getRequest().get(i), i);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
    }
    for (int i = 0; i < element.getProgramCode().size(); i++) {
      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
    }
    if (element.hasServiced()) {
      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
    }
    if (element.hasLocation()) {
      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "AddedItemComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeClaimResponseBodySiteComponent(t, "AddedItemComponent", "bodySite", element.getBodySite().get(i), i);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "AddedItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeClaimResponseBodySiteComponent(Complex parent, String parentType, String name, ClaimResponse.BodySiteComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "bodySite", name, element, index);
    for (int i = 0; i < element.getSite().size(); i++) {
      composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i);
    }
    for (int i = 0; i < element.getSubSite().size(); i++) {
      composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i);
    }
  }

  protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "detail", name, element, index);
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "AddedItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "AddedItemDetailComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "AddedItemDetailComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "AddedItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getSubDetail().size(); i++) {
      composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
    }
  }

  protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "subDetail", name, element, index);
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "AddedItemSubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "AddedItemSubDetailComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "AddedItemSubDetailComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeClaimResponseReviewOutcomeComponent(t, "AddedItemSubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
  }

  protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "total", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "payment", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
    }
    if (element.hasAdjustment()) {
      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
    }
    if (element.hasAdjustmentReason()) {
      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
    }
    if (element.hasDateElement()) {
      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
    }
  }

  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "processNote", name, element, index);
    if (element.hasNumberElement()) {
      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "NoteComponent", "type", element.getType(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
    }
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
    }
  }

  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "insurance", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasFocalElement()) {
      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
    }
    if (element.hasCoverage()) {
      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
    }
    if (element.hasBusinessArrangementElement()) {
      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
    }
    if (element.hasClaimResponse()) {
      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
    }
  }

  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "error", name, element, index);
    if (element.hasItemSequenceElement()) {
      composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1);
    }
    if (element.hasDetailSequenceElement()) {
      composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1);
    }
    if (element.hasSubDetailSequenceElement()) {
      composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getExpression().size(); i++) {
      composeString(t, "ErrorComponent", "expression", element.getExpression().get(i), i);
    }
  }

  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "ClinicalImpression", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1);
    }
    if (element.hasEffective()) {
      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
    }
    if (element.hasPerformer()) {
      composeReference(t, "ClinicalImpression", "performer", element.getPerformer(), -1);
    }
    if (element.hasPrevious()) {
      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
    }
    for (int i = 0; i < element.getProblem().size(); i++) {
      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
    }
    if (element.hasChangePattern()) {
      composeCodeableConcept(t, "ClinicalImpression", "changePattern", element.getChangePattern(), -1);
    }
    for (int i = 0; i < element.getProtocol().size(); i++) {
      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
    }
    if (element.hasSummaryElement()) {
      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
    }
    for (int i = 0; i < element.getFinding().size(); i++) {
      composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
    }
    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) {
      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
    }
    for (int i = 0; i < element.getPrognosisReference().size(); i++) {
      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
    }
  }

  protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "finding", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "ClinicalImpressionFindingComponent", "item", element.getItem(), -1);
    }
    if (element.hasBasisElement()) {
      composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1);
    }
  }

  protected void composeClinicalUseDefinition(Complex parent, String parentType, String name, ClinicalUseDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "ClinicalUseDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ClinicalUseDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "ClinicalUseDefinition", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "ClinicalUseDefinition", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "ClinicalUseDefinition", "subject", element.getSubject().get(i), i);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "ClinicalUseDefinition", "status", element.getStatus(), -1);
    }
    if (element.hasContraindication()) {
      composeClinicalUseDefinitionContraindicationComponent(t, "ClinicalUseDefinition", "contraindication", element.getContraindication(), -1);
    }
    if (element.hasIndication()) {
      composeClinicalUseDefinitionIndicationComponent(t, "ClinicalUseDefinition", "indication", element.getIndication(), -1);
    }
    if (element.hasInteraction()) {
      composeClinicalUseDefinitionInteractionComponent(t, "ClinicalUseDefinition", "interaction", element.getInteraction(), -1);
    }
    for (int i = 0; i < element.getPopulation().size(); i++) {
      composeReference(t, "ClinicalUseDefinition", "population", element.getPopulation().get(i), i);
    }
    for (int i = 0; i < element.getLibrary().size(); i++) {
      composeCanonical(t, "ClinicalUseDefinition", "library", element.getLibrary().get(i), i);
    }
    if (element.hasUndesirableEffect()) {
      composeClinicalUseDefinitionUndesirableEffectComponent(t, "ClinicalUseDefinition", "undesirableEffect", element.getUndesirableEffect(), -1);
    }
    if (element.hasWarning()) {
      composeClinicalUseDefinitionWarningComponent(t, "ClinicalUseDefinition", "warning", element.getWarning(), -1);
    }
  }

  protected void composeClinicalUseDefinitionContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "contraindication", name, element, index);
    if (element.hasDiseaseSymptomProcedure()) {
      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
    }
    if (element.hasDiseaseStatus()) {
      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
    }
    for (int i = 0; i < element.getComorbidity().size(); i++) {
      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i);
    }
    for (int i = 0; i < element.getIndication().size(); i++) {
      composeReference(t, "ClinicalUseDefinitionContraindicationComponent", "indication", element.getIndication().get(i), i);
    }
    if (element.hasApplicability()) {
      composeExpression(t, "ClinicalUseDefinitionContraindicationComponent", "applicability", element.getApplicability(), -1);
    }
    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
    }
  }

  protected void composeClinicalUseDefinitionContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "otherTherapy", name, element, index);
    if (element.hasRelationshipType()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "relationshipType", element.getRelationshipType(), -1);
    }
    if (element.hasTreatment()) {
      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "treatment", element.getTreatment(), -1);
    }
  }

  protected void composeClinicalUseDefinitionIndicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "indication", name, element, index);
    if (element.hasDiseaseSymptomProcedure()) {
      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
    }
    if (element.hasDiseaseStatus()) {
      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
    }
    for (int i = 0; i < element.getComorbidity().size(); i++) {
      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "comorbidity", element.getComorbidity().get(i), i);
    }
    if (element.hasIntendedEffect()) {
      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1);
    }
    if (element.hasDuration()) {
      composeType(t, "ClinicalUseDefinitionIndicationComponent", "duration", element.getDuration(), -1);
    }
    for (int i = 0; i < element.getUndesirableEffect().size(); i++) {
      composeReference(t, "ClinicalUseDefinitionIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i);
    }
    if (element.hasApplicability()) {
      composeExpression(t, "ClinicalUseDefinitionIndicationComponent", "applicability", element.getApplicability(), -1);
    }
    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
    }
  }

  protected void composeClinicalUseDefinitionInteractionComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "interaction", name, element, index);
    for (int i = 0; i < element.getInteractant().size(); i++) {
      composeClinicalUseDefinitionInteractionInteractantComponent(t, "ClinicalUseDefinitionInteractionComponent", "interactant", element.getInteractant().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "type", element.getType(), -1);
    }
    if (element.hasEffect()) {
      composeCodeableReference(t, "ClinicalUseDefinitionInteractionComponent", "effect", element.getEffect(), -1);
    }
    if (element.hasIncidence()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "incidence", element.getIncidence(), -1);
    }
    for (int i = 0; i < element.getManagement().size(); i++) {
      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "management", element.getManagement().get(i), i);
    }
  }

  protected void composeClinicalUseDefinitionInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "interactant", name, element, index);
    if (element.hasItem()) {
      composeType(t, "ClinicalUseDefinitionInteractionInteractantComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeClinicalUseDefinitionUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "undesirableEffect", name, element, index);
    if (element.hasSymptomConditionEffect()) {
      composeCodeableReference(t, "ClinicalUseDefinitionUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1);
    }
    if (element.hasClassification()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "classification", element.getClassification(), -1);
    }
    if (element.hasFrequencyOfOccurrence()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1);
    }
  }

  protected void composeClinicalUseDefinitionWarningComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "warning", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ClinicalUseDefinitionWarningComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ClinicalUseDefinitionWarningComponent", "code", element.getCode(), -1);
    }
  }

  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "CodeSystem", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "CodeSystem", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "CodeSystem", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "CodeSystem", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "CodeSystem", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "CodeSystem", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "CodeSystem", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "CodeSystem", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "CodeSystem", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "CodeSystem", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "CodeSystem", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "CodeSystem", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasCaseSensitiveElement()) {
      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
    }
    if (element.hasHierarchyMeaningElement()) {
      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
    }
    if (element.hasCompositionalElement()) {
      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
    }
    if (element.hasVersionNeededElement()) {
      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
    }
    if (element.hasContentElement()) {
      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
    }
    if (element.hasSupplementsElement()) {
      composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1);
    }
    if (element.hasCountElement()) {
      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
    }
    for (int i = 0; i < element.getFilter().size(); i++) {
      composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getConcept().size(); i++) {
      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
    }
  }

  protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "filter", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getOperator().size(); i++) {
      composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i);
    }
    if (element.hasValueElement()) {
      composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
    }
  }

  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "concept", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1);
    }
    for (int i = 0; i < element.getDesignation().size(); i++) {
      composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getConcept().size(); i++) {
      composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i);
    }
  }

  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "designation", name, element, index);
    if (element.hasLanguageElement()) {
      composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1);
    }
    if (element.hasUse()) {
      composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1);
    }
    for (int i = 0; i < element.getAdditionalUse().size(); i++) {
      composeCoding(t, "ConceptDefinitionDesignationComponent", "additionalUse", element.getAdditionalUse().get(i), i);
    }
    if (element.hasValueElement()) {
      composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Communication", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
    }
    for (int i = 0; i < element.getInResponseTo().size(); i++) {
      composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1);
    }
    for (int i = 0; i < element.getMedium().size(); i++) {
      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "Communication", "subject", element.getSubject(), -1);
    }
    if (element.hasTopic()) {
      composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1);
    }
    for (int i = 0; i < element.getAbout().size(); i++) {
      composeReference(t, "Communication", "about", element.getAbout().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Communication", "encounter", element.getEncounter(), -1);
    }
    if (element.hasSentElement()) {
      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
    }
    if (element.hasReceivedElement()) {
      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
    }
    for (int i = 0; i < element.getRecipient().size(); i++) {
      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
    }
    if (element.hasSender()) {
      composeReference(t, "Communication", "sender", element.getSender(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "Communication", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getPayload().size(); i++) {
      composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
    }
  }

  protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "payload", name, element, index);
    if (element.hasContent()) {
      composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "CommunicationRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "CommunicationRequest", "intent", element.getIntentElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    for (int i = 0; i < element.getMedium().size(); i++) {
      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getAbout().size(); i++) {
      composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getPayload().size(); i++) {
      composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
    }
    if (element.hasOccurrence()) {
      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1);
    }
    for (int i = 0; i < element.getRecipient().size(); i++) {
      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
    }
    for (int i = 0; i < element.getInformationProvider().size(); i++) {
      composeReference(t, "CommunicationRequest", "informationProvider", element.getInformationProvider().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "CommunicationRequest", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
    }
  }

  protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "payload", name, element, index);
    if (element.hasContent()) {
      composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeCanonicalResource(t, "CompartmentDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "CompartmentDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
    }
    if (element.hasSearchElement()) {
      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
    }
    for (int i = 0; i < element.getResource().size(); i++) {
      composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
    }
  }

  protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "resource", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1);
    }
    for (int i = 0; i < element.getParam().size(); i++) {
      composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasStartParamElement()) {
      composeUri(t, "CompartmentDefinitionResourceComponent", "startParam", element.getStartParamElement(), -1);
    }
    if (element.hasEndParamElement()) {
      composeUri(t, "CompartmentDefinitionResourceComponent", "endParam", element.getEndParamElement(), -1);
    }
  }

  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Composition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Composition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Composition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Composition", "version", element.getVersionElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "Composition", "subject", element.getSubject().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Composition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Composition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Composition", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Composition", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getAttester().size(); i++) {
      composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
    }
    if (element.hasCustodian()) {
      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
    }
    for (int i = 0; i < element.getRelatesTo().size(); i++) {
      composeRelatedArtifact(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
    }
    for (int i = 0; i < element.getSection().size(); i++) {
      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
    }
  }

  protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "attester", name, element, index);
    if (element.hasMode()) {
      composeCodeableConcept(t, "CompositionAttesterComponent", "mode", element.getMode(), -1);
    }
    if (element.hasTimeElement()) {
      composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1);
    }
    if (element.hasParty()) {
      composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1);
    }
  }

  protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "event", name, element, index);
    if (element.hasPeriod()) {
      composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeCodeableReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "section", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "SectionComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
    }
    if (element.hasFocus()) {
      composeReference(t, "SectionComponent", "focus", element.getFocus(), -1);
    }
    if (element.hasText()) {
      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
    }
    if (element.hasOrderedBy()) {
      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
    }
    for (int i = 0; i < element.getEntry().size(); i++) {
      composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i);
    }
    if (element.hasEmptyReason()) {
      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
    }
    for (int i = 0; i < element.getSection().size(); i++) {
      composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
    }
  }

  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "ConceptMap", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ConceptMap", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ConceptMap", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ConceptMap", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ConceptMap", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "ConceptMap", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "ConceptMap", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "ConceptMap", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "ConceptMap", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "ConceptMap", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "ConceptMap", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "ConceptMap", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeConceptMapPropertyComponent(t, "ConceptMap", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getAdditionalAttribute().size(); i++) {
      composeConceptMapAdditionalAttributeComponent(t, "ConceptMap", "additionalAttribute", element.getAdditionalAttribute().get(i), i);
    }
    if (element.hasSourceScope()) {
      composeType(t, "ConceptMap", "sourceScope", element.getSourceScope(), -1);
    }
    if (element.hasTargetScope()) {
      composeType(t, "ConceptMap", "targetScope", element.getTargetScope(), -1);
    }
    for (int i = 0; i < element.getGroup().size(); i++) {
      composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
    }
  }

  protected void composeConceptMapPropertyComponent(Complex parent, String parentType, String name, ConceptMap.PropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasSystemElement()) {
      composeCanonical(t, "PropertyComponent", "system", element.getSystemElement(), -1);
    }
  }

  protected void composeConceptMapAdditionalAttributeComponent(Complex parent, String parentType, String name, ConceptMap.AdditionalAttributeComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "additionalAttribute", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "AdditionalAttributeComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "AdditionalAttributeComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "AdditionalAttributeComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "AdditionalAttributeComponent", "type", element.getTypeElement(), -1);
    }
  }

  protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "group", name, element, index);
    if (element.hasSourceElement()) {
      composeCanonical(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1);
    }
    if (element.hasTargetElement()) {
      composeCanonical(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1);
    }
    for (int i = 0; i < element.getElement().size(); i++) {
      composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i);
    }
    if (element.hasUnmapped()) {
      composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1);
    }
  }

  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "element", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "SourceElementComponent", "valueSet", element.getValueSetElement(), -1);
    }
    if (element.hasNoMapElement()) {
      composeBoolean(t, "SourceElementComponent", "noMap", element.getNoMapElement(), -1);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i);
    }
  }

  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "target", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "TargetElementComponent", "valueSet", element.getValueSetElement(), -1);
    }
    if (element.hasRelationshipElement()) {
      composeEnum(t, "TargetElementComponent", "relationship", element.getRelationshipElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeConceptMapMappingPropertyComponent(t, "TargetElementComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getDependsOn().size(); i++) {
      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i);
    }
    for (int i = 0; i < element.getProduct().size(); i++) {
      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i);
    }
  }

  protected void composeConceptMapMappingPropertyComponent(Complex parent, String parentType, String name, ConceptMap.MappingPropertyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "property", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "MappingPropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "MappingPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "dependsOn", name, element, index);
    if (element.hasAttributeElement()) {
      composeCode(t, "OtherElementComponent", "attribute", element.getAttributeElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "OtherElementComponent", "value", element.getValue(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "OtherElementComponent", "valueSet", element.getValueSetElement(), -1);
    }
  }

  protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "unmapped", name, element, index);
    if (element.hasModeElement()) {
      composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "valueSet", element.getValueSetElement(), -1);
    }
    if (element.hasRelationshipElement()) {
      composeEnum(t, "ConceptMapGroupUnmappedComponent", "relationship", element.getRelationshipElement(), -1);
    }
    if (element.hasOtherMapElement()) {
      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "otherMap", element.getOtherMapElement(), -1);
    }
  }

  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Condition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasClinicalStatus()) {
      composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1);
    }
    if (element.hasVerificationStatus()) {
      composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
    }
    if (element.hasSeverity()) {
      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "Condition", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Condition", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOnset()) {
      composeType(t, "Condition", "onset", element.getOnset(), -1);
    }
    if (element.hasAbatement()) {
      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
    }
    if (element.hasRecordedDateElement()) {
      composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeConditionParticipantComponent(t, "Condition", "participant", element.getParticipant().get(i), i);
    }
    for (int i = 0; i < element.getStage().size(); i++) {
      composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i);
    }
    for (int i = 0; i < element.getEvidence().size(); i++) {
      composeCodeableReference(t, "Condition", "evidence", element.getEvidence().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
    }
  }

  protected void composeConditionParticipantComponent(Complex parent, String parentType, String name, Condition.ConditionParticipantComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "participant", name, element, index);
    if (element.hasFunction()) {
      composeCodeableConcept(t, "ConditionParticipantComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ConditionParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "stage", name, element, index);
    if (element.hasSummary()) {
      composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1);
    }
    for (int i = 0; i < element.getAssessment().size(); i++) {
      composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1);
    }
  }

  protected void composeConditionDefinition(Complex parent, String parentType, String name, ConditionDefinition element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeMetadataResource(t, "ConditionDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ConditionDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ConditionDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ConditionDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ConditionDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ConditionDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ConditionDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "ConditionDefinition", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ConditionDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ConditionDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ConditionDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ConditionDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ConditionDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ConditionDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ConditionDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ConditionDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ConditionDefinition", "code", element.getCode(), -1);
    }
    if (element.hasSeverity()) {
      composeCodeableConcept(t, "ConditionDefinition", "severity", element.getSeverity(), -1);
    }
    if (element.hasBodySite()) {
      composeCodeableConcept(t, "ConditionDefinition", "bodySite", element.getBodySite(), -1);
    }
    if (element.hasStage()) {
      composeCodeableConcept(t, "ConditionDefinition", "stage", element.getStage(), -1);
    }
    if (element.hasHasSeverityElement()) {
      composeBoolean(t, "ConditionDefinition", "hasSeverity", element.getHasSeverityElement(), -1);
    }
    if (element.hasHasBodySiteElement()) {
      composeBoolean(t, "ConditionDefinition", "hasBodySite", element.getHasBodySiteElement(), -1);
    }
    if (element.hasHasStageElement()) {
      composeBoolean(t, "ConditionDefinition", "hasStage", element.getHasStageElement(), -1);
    }
    for (int i = 0; i < element.getDefinition().size(); i++) {
      composeUri(t, "ConditionDefinition", "definition", element.getDefinition().get(i), i);
    }
    for (int i = 0; i < element.getObservation().size(); i++) {
      composeConditionDefinitionObservationComponent(t, "ConditionDefinition", "observation", element.getObservation().get(i), i);
    }
    for (int i = 0; i < element.getMedication().size(); i++) {
      composeConditionDefinitionMedicationComponent(t, "ConditionDefinition", "medication", element.getMedication().get(i), i);
    }
    for (int i = 0; i < element.getPrecondition().size(); i++) {
      composeConditionDefinitionPreconditionComponent(t, "ConditionDefinition", "precondition", element.getPrecondition().get(i), i);
    }
    for (int i = 0; i < element.getTeam().size(); i++) {
      composeReference(t, "ConditionDefinition", "team", element.getTeam().get(i), i);
    }
    for (int i = 0; i < element.getQuestionnaire().size(); i++) {
      composeConditionDefinitionQuestionnaireComponent(t, "ConditionDefinition", "questionnaire", element.getQuestionnaire().get(i), i);
    }
    for (int i = 0; i < element.getPlan().size(); i++) {
      composeConditionDefinitionPlanComponent(t, "ConditionDefinition", "plan", element.getPlan().get(i), i);
    }
  }

  protected void composeConditionDefinitionObservationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionObservationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "observation", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "category", element.getCategory(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "code", element.getCode(), -1);
    }
  }

  protected void composeConditionDefinitionMedicationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionMedicationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "medication", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "category", element.getCategory(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "code", element.getCode(), -1);
    }
  }

  protected void composeConditionDefinitionPreconditionComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPreconditionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "precondition", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "ConditionDefinitionPreconditionComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ConditionDefinitionPreconditionComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ConditionDefinitionPreconditionComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeConditionDefinitionQuestionnaireComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionQuestionnaireComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "questionnaire", name, element, index);
    if (element.hasPurposeElement()) {
      composeEnum(t, "ConditionDefinitionQuestionnaireComponent", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "ConditionDefinitionQuestionnaireComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeConditionDefinitionPlanComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPlanComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "plan", name, element, index);
    if (element.hasRole()) {
      composeCodeableConcept(t, "ConditionDefinitionPlanComponent", "role", element.getRole(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "ConditionDefinitionPlanComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Consent", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "Consent", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDate(t, "Consent", "date", element.getDateElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Consent", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getGrantor().size(); i++) {
      composeReference(t, "Consent", "grantor", element.getGrantor().get(i), i);
    }
    for (int i = 0; i < element.getGrantee().size(); i++) {
      composeReference(t, "Consent", "grantee", element.getGrantee().get(i), i);
    }
    for (int i = 0; i < element.getManager().size(); i++) {
      composeReference(t, "Consent", "manager", element.getManager().get(i), i);
    }
    for (int i = 0; i < element.getController().size(); i++) {
      composeReference(t, "Consent", "controller", element.getController().get(i), i);
    }
    for (int i = 0; i < element.getSourceAttachment().size(); i++) {
      composeAttachment(t, "Consent", "sourceAttachment", element.getSourceAttachment().get(i), i);
    }
    for (int i = 0; i < element.getSourceReference().size(); i++) {
      composeReference(t, "Consent", "sourceReference", element.getSourceReference().get(i), i);
    }
    for (int i = 0; i < element.getRegulatoryBasis().size(); i++) {
      composeCodeableConcept(t, "Consent", "regulatoryBasis", element.getRegulatoryBasis().get(i), i);
    }
    if (element.hasPolicyBasis()) {
      composeConsentPolicyBasisComponent(t, "Consent", "policyBasis", element.getPolicyBasis(), -1);
    }
    for (int i = 0; i < element.getPolicyText().size(); i++) {
      composeReference(t, "Consent", "policyText", element.getPolicyText().get(i), i);
    }
    for (int i = 0; i < element.getVerification().size(); i++) {
      composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i);
    }
    if (element.hasDecisionElement()) {
      composeEnum(t, "Consent", "decision", element.getDecisionElement(), -1);
    }
    for (int i = 0; i < element.getProvision().size(); i++) {
      composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision().get(i), i);
    }
  }

  protected void composeConsentPolicyBasisComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyBasisComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "policyBasis", name, element, index);
    if (element.hasReference()) {
      composeReference(t, "ConsentPolicyBasisComponent", "reference", element.getReference(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "ConsentPolicyBasisComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "verification", name, element, index);
    if (element.hasVerifiedElement()) {
      composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1);
    }
    if (element.hasVerificationType()) {
      composeCodeableConcept(t, "ConsentVerificationComponent", "verificationType", element.getVerificationType(), -1);
    }
    if (element.hasVerifiedBy()) {
      composeReference(t, "ConsentVerificationComponent", "verifiedBy", element.getVerifiedBy(), -1);
    }
    if (element.hasVerifiedWith()) {
      composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1);
    }
    for (int i = 0; i < element.getVerificationDate().size(); i++) {
      composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDate().get(i), i);
    }
  }

  protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "provision", name, element, index);
    if (element.hasPeriod()) {
      composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getActor().size(); i++) {
      composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i);
    }
    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
      composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i);
    }
    for (int i = 0; i < element.getPurpose().size(); i++) {
      composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i);
    }
    for (int i = 0; i < element.getDocumentType().size(); i++) {
      composeCoding(t, "ProvisionComponent", "documentType", element.getDocumentType().get(i), i);
    }
    for (int i = 0; i < element.getResourceType().size(); i++) {
      composeCoding(t, "ProvisionComponent", "resourceType", element.getResourceType().get(i), i);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i);
    }
    if (element.hasDataPeriod()) {
      composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1);
    }
    for (int i = 0; i < element.getData().size(); i++) {
      composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i);
    }
    if (element.hasExpression()) {
      composeExpression(t, "ProvisionComponent", "expression", element.getExpression(), -1);
    }
    for (int i = 0; i < element.getProvision().size(); i++) {
      composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i);
    }
  }

  protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "actor", name, element, index);
    if (element.hasRole()) {
      composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "data", name, element, index);
    if (element.hasMeaningElement()) {
      composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Contract", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasUrlElement()) {
      composeUri(t, "Contract", "url", element.getUrlElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Contract", "version", element.getVersionElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
    }
    if (element.hasLegalState()) {
      composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1);
    }
    if (element.hasInstantiatesCanonical()) {
      composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1);
    }
    if (element.hasInstantiatesUriElement()) {
      composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1);
    }
    if (element.hasContentDerivative()) {
      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
    }
    if (element.hasIssuedElement()) {
      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
    }
    if (element.hasApplies()) {
      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
    }
    if (element.hasExpirationType()) {
      composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
    }
    for (int i = 0; i < element.getAuthority().size(); i++) {
      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
    }
    for (int i = 0; i < element.getDomain().size(); i++) {
      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
    }
    for (int i = 0; i < element.getSite().size(); i++) {
      composeReference(t, "Contract", "site", element.getSite().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Contract", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Contract", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1);
    }
    for (int i = 0; i < element.getAlias().size(); i++) {
      composeString(t, "Contract", "alias", element.getAlias().get(i), i);
    }
    if (element.hasAuthor()) {
      composeReference(t, "Contract", "author", element.getAuthor(), -1);
    }
    if (element.hasScope()) {
      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
    }
    if (element.hasTopic()) {
      composeType(t, "Contract", "topic", element.getTopic(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getSubType().size(); i++) {
      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
    }
    if (element.hasContentDefinition()) {
      composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1);
    }
    for (int i = 0; i < element.getTerm().size(); i++) {
      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
      composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i);
    }
    for (int i = 0; i < element.getSigner().size(); i++) {
      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
    }
    for (int i = 0; i < element.getFriendly().size(); i++) {
      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
    }
    for (int i = 0; i < element.getLegal().size(); i++) {
      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
    }
    for (int i = 0; i < element.getRule().size(); i++) {
      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
    }
    if (element.hasLegallyBinding()) {
      composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1);
    }
  }

  protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "contentDefinition", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1);
    }
    if (element.hasSubType()) {
      composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1);
    }
    if (element.hasPublisher()) {
      composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1);
    }
    if (element.hasPublicationDateElement()) {
      composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1);
    }
    if (element.hasPublicationStatusElement()) {
      composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1);
    }
  }

  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "term", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasIssuedElement()) {
      composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1);
    }
    if (element.hasApplies()) {
      composePeriod(t, "TermComponent", "applies", element.getApplies(), -1);
    }
    if (element.hasTopic()) {
      composeType(t, "TermComponent", "topic", element.getTopic(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1);
    }
    if (element.hasSubType()) {
      composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "TermComponent", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
      composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i);
    }
    if (element.hasOffer()) {
      composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1);
    }
    for (int i = 0; i < element.getAsset().size(); i++) {
      composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i);
    }
    for (int i = 0; i < element.getGroup().size(); i++) {
      composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i);
    }
  }

  protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "securityLabel", name, element, index);
    for (int i = 0; i < element.getNumber().size(); i++) {
      composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i);
    }
    if (element.hasClassification()) {
      composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getControl().size(); i++) {
      composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i);
    }
  }

  protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "offer", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getParty().size(); i++) {
      composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i);
    }
    if (element.hasTopic()) {
      composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1);
    }
    if (element.hasDecision()) {
      composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1);
    }
    for (int i = 0; i < element.getDecisionMode().size(); i++) {
      composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i);
    }
    for (int i = 0; i < element.getAnswer().size(); i++) {
      composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i);
    }
    if (element.hasTextElement()) {
      composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getLinkId().size(); i++) {
      composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i);
    }
    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
      composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
    }
  }

  protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "party", name, element, index);
    for (int i = 0; i < element.getReference().size(); i++) {
      composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1);
    }
  }

  protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "answer", name, element, index);
    if (element.hasValue()) {
      composeType(t, "AnswerComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "asset", name, element, index);
    if (element.hasScope()) {
      composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getTypeReference().size(); i++) {
      composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i);
    }
    for (int i = 0; i < element.getSubtype().size(); i++) {
      composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i);
    }
    if (element.hasRelationship()) {
      composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1);
    }
    for (int i = 0; i < element.getContext().size(); i++) {
      composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i);
    }
    if (element.hasConditionElement()) {
      composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1);
    }
    for (int i = 0; i < element.getPeriodType().size(); i++) {
      composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i);
    }
    for (int i = 0; i < element.getPeriod().size(); i++) {
      composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i);
    }
    for (int i = 0; i < element.getUsePeriod().size(); i++) {
      composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i);
    }
    if (element.hasTextElement()) {
      composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getLinkId().size(); i++) {
      composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i);
    }
    for (int i = 0; i < element.getAnswer().size(); i++) {
      composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i);
    }
    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
      composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
    }
    for (int i = 0; i < element.getValuedItem().size(); i++) {
      composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i);
    }
  }

  protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "context", name, element, index);
    if (element.hasReference()) {
      composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i);
    }
    if (element.hasTextElement()) {
      composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1);
    }
  }

  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "valuedItem", name, element, index);
    if (element.hasEntity()) {
      composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasEffectiveTimeElement()) {
      composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasPointsElement()) {
      composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1);
    }
    if (element.hasPaymentElement()) {
      composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1);
    }
    if (element.hasPaymentDateElement()) {
      composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1);
    }
    if (element.hasResponsible()) {
      composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1);
    }
    if (element.hasRecipient()) {
      composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1);
    }
    for (int i = 0; i < element.getLinkId().size(); i++) {
      composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i);
    }
    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
      composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
    }
  }

  protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "action", name, element, index);
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i);
    }
    if (element.hasIntent()) {
      composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1);
    }
    for (int i = 0; i < element.getLinkId().size(); i++) {
      composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1);
    }
    if (element.hasContext()) {
      composeReference(t, "ActionComponent", "context", element.getContext(), -1);
    }
    for (int i = 0; i < element.getContextLinkId().size(); i++) {
      composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i);
    }
    if (element.hasOccurrence()) {
      composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1);
    }
    for (int i = 0; i < element.getRequester().size(); i++) {
      composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i);
    }
    for (int i = 0; i < element.getRequesterLinkId().size(); i++) {
      composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i);
    }
    for (int i = 0; i < element.getPerformerType().size(); i++) {
      composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i);
    }
    if (element.hasPerformerRole()) {
      composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1);
    }
    if (element.hasPerformer()) {
      composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1);
    }
    for (int i = 0; i < element.getPerformerLinkId().size(); i++) {
      composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "ActionComponent", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getReasonLinkId().size(); i++) {
      composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
      composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
    }
  }

  protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "subject", name, element, index);
    for (int i = 0; i < element.getReference().size(); i++) {
      composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1);
    }
  }

  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "signer", name, element, index);
    if (element.hasType()) {
      composeCoding(t, "SignatoryComponent", "type", element.getType(), -1);
    }
    if (element.hasParty()) {
      composeReference(t, "SignatoryComponent", "party", element.getParty(), -1);
    }
    for (int i = 0; i < element.getSignature().size(); i++) {
      composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i);
    }
  }

  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "friendly", name, element, index);
    if (element.hasContent()) {
      composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "legal", name, element, index);
    if (element.hasContent()) {
      composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "rule", name, element, index);
    if (element.hasContent()) {
      composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "Coverage", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "Coverage", "kind", element.getKindElement(), -1);
    }
    for (int i = 0; i < element.getPaymentBy().size(); i++) {
      composeCoveragePaymentByComponent(t, "Coverage", "paymentBy", element.getPaymentBy().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
    }
    if (element.hasPolicyHolder()) {
      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
    }
    if (element.hasSubscriber()) {
      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
    }
    for (int i = 0; i < element.getSubscriberId().size(); i++) {
      composeIdentifier(t, "Coverage", "subscriberId", element.getSubscriberId().get(i), i);
    }
    if (element.hasBeneficiary()) {
      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
    }
    if (element.hasDependentElement()) {
      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
    }
    if (element.hasRelationship()) {
      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "Coverage", "insurer", element.getInsurer(), -1);
    }
    for (int i = 0; i < element.getClass_().size(); i++) {
      composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i);
    }
    if (element.hasOrderElement()) {
      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
    }
    if (element.hasNetworkElement()) {
      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
    }
    for (int i = 0; i < element.getCostToBeneficiary().size(); i++) {
      composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i);
    }
    if (element.hasSubrogationElement()) {
      composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1);
    }
    for (int i = 0; i < element.getContract().size(); i++) {
      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
    }
    if (element.hasInsurancePlan()) {
      composeReference(t, "Coverage", "insurancePlan", element.getInsurancePlan(), -1);
    }
  }

  protected void composeCoveragePaymentByComponent(Complex parent, String parentType, String name, Coverage.CoveragePaymentByComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "paymentBy", name, element, index);
    if (element.hasParty()) {
      composeReference(t, "CoveragePaymentByComponent", "party", element.getParty(), -1);
    }
    if (element.hasResponsibilityElement()) {
      composeString(t, "CoveragePaymentByComponent", "responsibility", element.getResponsibilityElement(), -1);
    }
  }

  protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "class", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeIdentifier(t, "ClassComponent", "value", element.getValue(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ClassComponent", "name", element.getNameElement(), -1);
    }
  }

  protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "costToBeneficiary", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "CostToBeneficiaryComponent", "category", element.getCategory(), -1);
    }
    if (element.hasNetwork()) {
      composeCodeableConcept(t, "CostToBeneficiaryComponent", "network", element.getNetwork(), -1);
    }
    if (element.hasUnit()) {
      composeCodeableConcept(t, "CostToBeneficiaryComponent", "unit", element.getUnit(), -1);
    }
    if (element.hasTerm()) {
      composeCodeableConcept(t, "CostToBeneficiaryComponent", "term", element.getTerm(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1);
    }
    for (int i = 0; i < element.getException().size(); i++) {
      composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i);
    }
  }

  protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "exception", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "CoverageEligibilityRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1);
    }
    for (int i = 0; i < element.getPurpose().size(); i++) {
      composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeCoverageEligibilityRequestEventComponent(t, "CoverageEligibilityRequest", "event", element.getEvent().get(i), i);
    }
    if (element.hasServiced()) {
      composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1);
    }
    if (element.hasEnterer()) {
      composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1);
    }
    if (element.hasProvider()) {
      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1);
    }
    if (element.hasFacility()) {
      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i);
    }
  }

  protected void composeCoverageEligibilityRequestEventComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.CoverageEligibilityRequestEventComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "event", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CoverageEligibilityRequestEventComponent", "type", element.getType(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "CoverageEligibilityRequestEventComponent", "when", element.getWhen(), -1);
    }
  }

  protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "supportingInfo", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasInformation()) {
      composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1);
    }
    if (element.hasAppliesToAllElement()) {
      composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1);
    }
  }

  protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "insurance", name, element, index);
    if (element.hasFocalElement()) {
      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
    }
    if (element.hasCoverage()) {
      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
    }
    if (element.hasBusinessArrangementElement()) {
      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
    }
  }

  protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "item", name, element, index);
    for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) {
      composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i);
    }
    if (element.hasProvider()) {
      composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFacility()) {
      composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "diagnosis", name, element, index);
    if (element.hasDiagnosis()) {
      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
    }
  }

  protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeDomainResource(t, "CoverageEligibilityResponse", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getPurpose().size(); i++) {
      composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeCoverageEligibilityResponseEventComponent(t, "CoverageEligibilityResponse", "event", element.getEvent().get(i), i);
    }
    if (element.hasServiced()) {
      composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1);
    }
    if (element.hasRequestor()) {
      composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1);
    }
    if (element.hasRequest()) {
      composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1);
    }
    if (element.hasOutcomeElement()) {
      composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1);
    }
    if (element.hasDispositionElement()) {
      composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i);
    }
    if (element.hasPreAuthRefElement()) {
      composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
    }
    if (element.hasForm()) {
      composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1);
    }
    for (int i = 0; i < element.getError().size(); i++) {
      composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i);
    }
  }

  protected void composeCoverageEligibilityResponseEventComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.CoverageEligibilityResponseEventComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "event", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CoverageEligibilityResponseEventComponent", "type", element.getType(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "CoverageEligibilityResponseEventComponent", "when", element.getWhen(), -1);
    }
  }

  protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "insurance", name, element, index);
    if (element.hasCoverage()) {
      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
    }
    if (element.hasInforceElement()) {
      composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1);
    }
    if (element.hasBenefitPeriod()) {
      composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i);
    }
  }

  protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) {
    if (element == null) 
      return;
    Complex t;
    if (Utilities.noString(parentType))
      t = parent;
    else {
      t = parent.predicate("fhir:"+name,index > -1);
    }
    composeBackboneElement(t, "item", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i);
    }
    if (element.hasProvider()) {
      composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1);
    }
    if (element.hasExcludedElement()) {
      composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ItemsComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasNetwork()) {
      composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1);
    }
    if (element.hasUnit()) {
      composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1);
    }
    if (element.hasTerm()) {
      composeCodeableConcept(t, "ItemsComponent", "term",