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", element.getTerm(), -1);
    }
    for (int i = 0; i < element.getBenefit().size(); i++) {
      composeCoverageEligibilityResponseBenefitComponent(t, "ItemsComponent", "benefit", element.getBenefit().get(i), i);
    }
    if (element.hasAuthorizationRequiredElement()) {
      composeBoolean(t, "ItemsComponent", "authorizationRequired", element.getAuthorizationRequiredElement(), -1);
    }
    for (int i = 0; i < element.getAuthorizationSupporting().size(); i++) {
      composeCodeableConcept(t, "ItemsComponent", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i);
    }
    if (element.hasAuthorizationUrlElement()) {
      composeUri(t, "ItemsComponent", "authorizationUrl", element.getAuthorizationUrlElement(), -1);
    }
  }

  protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent 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, "benefit", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
    }
    if (element.hasAllowed()) {
      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
    }
    if (element.hasUsed()) {
      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
    }
  }

  protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent 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.hasCode()) {
      composeCodeableConcept(t, "ErrorsComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getExpression().size(); i++) {
      composeString(t, "ErrorsComponent", "expression", element.getExpression().get(i), i);
    }
  }

  protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue 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, "DetectedIssue", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1);
    }
    if (element.hasSeverityElement()) {
      composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "DetectedIssue", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "DetectedIssue", "encounter", element.getEncounter(), -1);
    }
    if (element.hasIdentified()) {
      composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getImplicated().size(); i++) {
      composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i);
    }
    for (int i = 0; i < element.getEvidence().size(); i++) {
      composeDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i);
    }
    if (element.hasDetailElement()) {
      composeMarkdown(t, "DetectedIssue", "detail", element.getDetailElement(), -1);
    }
    if (element.hasReferenceElement()) {
      composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1);
    }
    for (int i = 0; i < element.getMitigation().size(); i++) {
      composeDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i);
    }
  }

  protected void composeDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent 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, "evidence", name, element, index);
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "DetectedIssueEvidenceComponent", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeReference(t, "DetectedIssueEvidenceComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent 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, "mitigation", name, element, index);
    if (element.hasAction()) {
      composeCodeableConcept(t, "DetectedIssueMitigationComponent", "action", element.getAction(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "DetectedIssueMitigationComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "DetectedIssueMitigationComponent", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DetectedIssueMitigationComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeDevice(Complex parent, String parentType, String name, Device 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, "Device", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasDisplayNameElement()) {
      composeString(t, "Device", "displayName", element.getDisplayNameElement(), -1);
    }
    if (element.hasDefinition()) {
      composeCodeableReference(t, "Device", "definition", element.getDefinition(), -1);
    }
    for (int i = 0; i < element.getUdiCarrier().size(); i++) {
      composeDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Device", "status", element.getStatusElement(), -1);
    }
    if (element.hasAvailabilityStatus()) {
      composeCodeableConcept(t, "Device", "availabilityStatus", element.getAvailabilityStatus(), -1);
    }
    if (element.hasBiologicalSourceEvent()) {
      composeIdentifier(t, "Device", "biologicalSourceEvent", element.getBiologicalSourceEvent(), -1);
    }
    if (element.hasManufacturerElement()) {
      composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1);
    }
    if (element.hasManufactureDateElement()) {
      composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1);
    }
    if (element.hasExpirationDateElement()) {
      composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1);
    }
    if (element.hasLotNumberElement()) {
      composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1);
    }
    if (element.hasSerialNumberElement()) {
      composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeDeviceNameComponent(t, "Device", "name", element.getName().get(i), i);
    }
    if (element.hasModelNumberElement()) {
      composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1);
    }
    if (element.hasPartNumberElement()) {
      composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Device", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "Device", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getVersion().size(); i++) {
      composeDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i);
    }
    for (int i = 0; i < element.getConformsTo().size(); i++) {
      composeDeviceConformsToComponent(t, "Device", "conformsTo", element.getConformsTo().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i);
    }
    if (element.hasMode()) {
      composeCodeableConcept(t, "Device", "mode", element.getMode(), -1);
    }
    if (element.hasCycle()) {
      composeCount(t, "Device", "cycle", element.getCycle(), -1);
    }
    if (element.hasDuration()) {
      composeDuration(t, "Device", "duration", element.getDuration(), -1);
    }
    if (element.hasOwner()) {
      composeReference(t, "Device", "owner", element.getOwner(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactPoint(t, "Device", "contact", element.getContact().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "Device", "location", element.getLocation(), -1);
    }
    if (element.hasUrlElement()) {
      composeUri(t, "Device", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "Device", "endpoint", element.getEndpoint().get(i), i);
    }
    for (int i = 0; i < element.getGateway().size(); i++) {
      composeCodeableReference(t, "Device", "gateway", element.getGateway().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Device", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getSafety().size(); i++) {
      composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i);
    }
    if (element.hasParent()) {
      composeReference(t, "Device", "parent", element.getParent(), -1);
    }
  }

  protected void composeDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent 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, "udiCarrier", name, element, index);
    if (element.hasDeviceIdentifierElement()) {
      composeString(t, "DeviceUdiCarrierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
    }
    if (element.hasIssuerElement()) {
      composeUri(t, "DeviceUdiCarrierComponent", "issuer", element.getIssuerElement(), -1);
    }
    if (element.hasJurisdictionElement()) {
      composeUri(t, "DeviceUdiCarrierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
    }
    if (element.hasCarrierAIDCElement()) {
      composeBase64Binary(t, "DeviceUdiCarrierComponent", "carrierAIDC", element.getCarrierAIDCElement(), -1);
    }
    if (element.hasCarrierHRFElement()) {
      composeString(t, "DeviceUdiCarrierComponent", "carrierHRF", element.getCarrierHRFElement(), -1);
    }
    if (element.hasEntryTypeElement()) {
      composeEnum(t, "DeviceUdiCarrierComponent", "entryType", element.getEntryTypeElement(), -1);
    }
  }

  protected void composeDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceNameComponent 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, "name", name, element, index);
    if (element.hasValueElement()) {
      composeString(t, "DeviceNameComponent", "value", element.getValueElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "DeviceNameComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeBoolean(t, "DeviceNameComponent", "display", element.getDisplayElement(), -1);
    }
  }

  protected void composeDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent 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.hasType()) {
      composeCodeableConcept(t, "DeviceVersionComponent", "type", element.getType(), -1);
    }
    if (element.hasComponent()) {
      composeIdentifier(t, "DeviceVersionComponent", "component", element.getComponent(), -1);
    }
    if (element.hasInstallDateElement()) {
      composeDateTime(t, "DeviceVersionComponent", "installDate", element.getInstallDateElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "DeviceVersionComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeDeviceConformsToComponent(Complex parent, String parentType, String name, Device.DeviceConformsToComponent 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, "conformsTo", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "DeviceConformsToComponent", "category", element.getCategory(), -1);
    }
    if (element.hasSpecification()) {
      composeCodeableConcept(t, "DeviceConformsToComponent", "specification", element.getSpecification(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "DeviceConformsToComponent", "version", element.getVersionElement(), -1);
    }
  }

  protected void composeDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent 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, "DevicePropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "DevicePropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeDeviceAssociation(Complex parent, String parentType, String name, DeviceAssociation 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, "DeviceAssociation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceAssociation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasDevice()) {
      composeReference(t, "DeviceAssociation", "device", element.getDevice(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DeviceAssociation", "category", element.getCategory().get(i), i);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "DeviceAssociation", "status", element.getStatus(), -1);
    }
    for (int i = 0; i < element.getStatusReason().size(); i++) {
      composeCodeableConcept(t, "DeviceAssociation", "statusReason", element.getStatusReason().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "DeviceAssociation", "subject", element.getSubject(), -1);
    }
    if (element.hasBodyStructure()) {
      composeReference(t, "DeviceAssociation", "bodyStructure", element.getBodyStructure(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "DeviceAssociation", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getOperation().size(); i++) {
      composeDeviceAssociationOperationComponent(t, "DeviceAssociation", "operation", element.getOperation().get(i), i);
    }
  }

  protected void composeDeviceAssociationOperationComponent(Complex parent, String parentType, String name, DeviceAssociation.DeviceAssociationOperationComponent 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.hasStatus()) {
      composeCodeableConcept(t, "DeviceAssociationOperationComponent", "status", element.getStatus(), -1);
    }
    for (int i = 0; i < element.getOperator().size(); i++) {
      composeReference(t, "DeviceAssociationOperationComponent", "operator", element.getOperator().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "DeviceAssociationOperationComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition 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, "DeviceDefinition", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "DeviceDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) {
      composeDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getRegulatoryIdentifier().size(); i++) {
      composeDeviceDefinitionRegulatoryIdentifierComponent(t, "DeviceDefinition", "regulatoryIdentifier", element.getRegulatoryIdentifier().get(i), i);
    }
    if (element.hasPartNumberElement()) {
      composeString(t, "DeviceDefinition", "partNumber", element.getPartNumberElement(), -1);
    }
    if (element.hasManufacturer()) {
      composeReference(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1);
    }
    for (int i = 0; i < element.getDeviceName().size(); i++) {
      composeDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i);
    }
    if (element.hasModelNumberElement()) {
      composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeDeviceDefinitionClassificationComponent(t, "DeviceDefinition", "classification", element.getClassification().get(i), i);
    }
    for (int i = 0; i < element.getConformsTo().size(); i++) {
      composeDeviceDefinitionConformsToComponent(t, "DeviceDefinition", "conformsTo", element.getConformsTo().get(i), i);
    }
    for (int i = 0; i < element.getHasPart().size(); i++) {
      composeDeviceDefinitionHasPartComponent(t, "DeviceDefinition", "hasPart", element.getHasPart().get(i), i);
    }
    for (int i = 0; i < element.getPackaging().size(); i++) {
      composeDeviceDefinitionPackagingComponent(t, "DeviceDefinition", "packaging", element.getPackaging().get(i), i);
    }
    for (int i = 0; i < element.getVersion().size(); i++) {
      composeDeviceDefinitionVersionComponent(t, "DeviceDefinition", "version", element.getVersion().get(i), i);
    }
    for (int i = 0; i < element.getSafety().size(); i++) {
      composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i);
    }
    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
      composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
    }
    for (int i = 0; i < element.getLanguageCode().size(); i++) {
      composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i);
    }
    if (element.hasOwner()) {
      composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composeDeviceDefinitionLinkComponent(t, "DeviceDefinition", "link", element.getLink().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getMaterial().size(); i++) {
      composeDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i);
    }
    for (int i = 0; i < element.getProductionIdentifierInUDI().size(); i++) {
      composeEnum(t, "DeviceDefinition", "productionIdentifierInUDI", element.getProductionIdentifierInUDI().get(i), i);
    }
    if (element.hasGuideline()) {
      composeDeviceDefinitionGuidelineComponent(t, "DeviceDefinition", "guideline", element.getGuideline(), -1);
    }
    if (element.hasCorrectiveAction()) {
      composeDeviceDefinitionCorrectiveActionComponent(t, "DeviceDefinition", "correctiveAction", element.getCorrectiveAction(), -1);
    }
    for (int i = 0; i < element.getChargeItem().size(); i++) {
      composeDeviceDefinitionChargeItemComponent(t, "DeviceDefinition", "chargeItem", element.getChargeItem().get(i), i);
    }
  }

  protected void composeDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent 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, "udiDeviceIdentifier", name, element, index);
    if (element.hasDeviceIdentifierElement()) {
      composeString(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
    }
    if (element.hasIssuerElement()) {
      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "issuer", element.getIssuerElement(), -1);
    }
    if (element.hasJurisdictionElement()) {
      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
    }
    for (int i = 0; i < element.getMarketDistribution().size(); i++) {
      composeDeviceDefinitionUdiDeviceIdentifierMarketDistributionComponent(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "marketDistribution", element.getMarketDistribution().get(i), i);
    }
  }

  protected void composeDeviceDefinitionUdiDeviceIdentifierMarketDistributionComponent(Complex parent, String parentType, String name, DeviceDefinition.UdiDeviceIdentifierMarketDistributionComponent 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, "marketDistribution", name, element, index);
    if (element.hasMarketPeriod()) {
      composePeriod(t, "UdiDeviceIdentifierMarketDistributionComponent", "marketPeriod", element.getMarketPeriod(), -1);
    }
    if (element.hasSubJurisdictionElement()) {
      composeUri(t, "UdiDeviceIdentifierMarketDistributionComponent", "subJurisdiction", element.getSubJurisdictionElement(), -1);
    }
  }

  protected void composeDeviceDefinitionRegulatoryIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionRegulatoryIdentifierComponent 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, "regulatoryIdentifier", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "DeviceDefinitionRegulatoryIdentifierComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasDeviceIdentifierElement()) {
      composeString(t, "DeviceDefinitionRegulatoryIdentifierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
    }
    if (element.hasIssuerElement()) {
      composeUri(t, "DeviceDefinitionRegulatoryIdentifierComponent", "issuer", element.getIssuerElement(), -1);
    }
    if (element.hasJurisdictionElement()) {
      composeUri(t, "DeviceDefinitionRegulatoryIdentifierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
    }
  }

  protected void composeDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent 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, "deviceName", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "DeviceDefinitionDeviceNameComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "DeviceDefinitionDeviceNameComponent", "type", element.getTypeElement(), -1);
    }
  }

  protected void composeDeviceDefinitionClassificationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionClassificationComponent 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, "DeviceDefinitionClassificationComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getJustification().size(); i++) {
      composeRelatedArtifact(t, "DeviceDefinitionClassificationComponent", "justification", element.getJustification().get(i), i);
    }
  }

  protected void composeDeviceDefinitionConformsToComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionConformsToComponent 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, "conformsTo", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "DeviceDefinitionConformsToComponent", "category", element.getCategory(), -1);
    }
    if (element.hasSpecification()) {
      composeCodeableConcept(t, "DeviceDefinitionConformsToComponent", "specification", element.getSpecification(), -1);
    }
    for (int i = 0; i < element.getVersion().size(); i++) {
      composeString(t, "DeviceDefinitionConformsToComponent", "version", element.getVersion().get(i), i);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeRelatedArtifact(t, "DeviceDefinitionConformsToComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeDeviceDefinitionHasPartComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionHasPartComponent 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, "hasPart", name, element, index);
    if (element.hasReference()) {
      composeReference(t, "DeviceDefinitionHasPartComponent", "reference", element.getReference(), -1);
    }
    if (element.hasCountElement()) {
      composeInteger(t, "DeviceDefinitionHasPartComponent", "count", element.getCountElement(), -1);
    }
  }

  protected void composeDeviceDefinitionPackagingComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPackagingComponent 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, "packaging", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "DeviceDefinitionPackagingComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "DeviceDefinitionPackagingComponent", "type", element.getType(), -1);
    }
    if (element.hasCountElement()) {
      composeInteger(t, "DeviceDefinitionPackagingComponent", "count", element.getCountElement(), -1);
    }
    for (int i = 0; i < element.getDistributor().size(); i++) {
      composeDeviceDefinitionPackagingDistributorComponent(t, "DeviceDefinitionPackagingComponent", "distributor", element.getDistributor().get(i), i);
    }
    for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) {
      composeDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinitionPackagingComponent", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getPackaging().size(); i++) {
      composeDeviceDefinitionPackagingComponent(t, "DeviceDefinitionPackagingComponent", "packaging", element.getPackaging().get(i), i);
    }
  }

  protected void composeDeviceDefinitionPackagingDistributorComponent(Complex parent, String parentType, String name, DeviceDefinition.PackagingDistributorComponent 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, "distributor", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "PackagingDistributorComponent", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getOrganizationReference().size(); i++) {
      composeReference(t, "PackagingDistributorComponent", "organizationReference", element.getOrganizationReference().get(i), i);
    }
  }

  protected void composeDeviceDefinitionVersionComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionVersionComponent 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.hasType()) {
      composeCodeableConcept(t, "DeviceDefinitionVersionComponent", "type", element.getType(), -1);
    }
    if (element.hasComponent()) {
      composeIdentifier(t, "DeviceDefinitionVersionComponent", "component", element.getComponent(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "DeviceDefinitionVersionComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent 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, "DeviceDefinitionPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "DeviceDefinitionPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeDeviceDefinitionLinkComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionLinkComponent 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.hasRelation()) {
      composeCoding(t, "DeviceDefinitionLinkComponent", "relation", element.getRelation(), -1);
    }
    if (element.hasRelatedDevice()) {
      composeCodeableReference(t, "DeviceDefinitionLinkComponent", "relatedDevice", element.getRelatedDevice(), -1);
    }
  }

  protected void composeDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent 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, "material", name, element, index);
    if (element.hasSubstance()) {
      composeCodeableConcept(t, "DeviceDefinitionMaterialComponent", "substance", element.getSubstance(), -1);
    }
    if (element.hasAlternateElement()) {
      composeBoolean(t, "DeviceDefinitionMaterialComponent", "alternate", element.getAlternateElement(), -1);
    }
    if (element.hasAllergenicIndicatorElement()) {
      composeBoolean(t, "DeviceDefinitionMaterialComponent", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
    }
  }

  protected void composeDeviceDefinitionGuidelineComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionGuidelineComponent 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, "guideline", name, element, index);
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "DeviceDefinitionGuidelineComponent", "useContext", element.getUseContext().get(i), i);
    }
    if (element.hasUsageInstructionElement()) {
      composeMarkdown(t, "DeviceDefinitionGuidelineComponent", "usageInstruction", element.getUsageInstructionElement(), -1);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "DeviceDefinitionGuidelineComponent", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getIndication().size(); i++) {
      composeCodeableConcept(t, "DeviceDefinitionGuidelineComponent", "indication", element.getIndication().get(i), i);
    }
    for (int i = 0; i < element.getContraindication().size(); i++) {
      composeCodeableConcept(t, "DeviceDefinitionGuidelineComponent", "contraindication", element.getContraindication().get(i), i);
    }
    for (int i = 0; i < element.getWarning().size(); i++) {
      composeCodeableConcept(t, "DeviceDefinitionGuidelineComponent", "warning", element.getWarning().get(i), i);
    }
    if (element.hasIntendedUseElement()) {
      composeString(t, "DeviceDefinitionGuidelineComponent", "intendedUse", element.getIntendedUseElement(), -1);
    }
  }

  protected void composeDeviceDefinitionCorrectiveActionComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCorrectiveActionComponent 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, "correctiveAction", name, element, index);
    if (element.hasRecallElement()) {
      composeBoolean(t, "DeviceDefinitionCorrectiveActionComponent", "recall", element.getRecallElement(), -1);
    }
    if (element.hasScopeElement()) {
      composeEnum(t, "DeviceDefinitionCorrectiveActionComponent", "scope", element.getScopeElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "DeviceDefinitionCorrectiveActionComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeDeviceDefinitionChargeItemComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionChargeItemComponent 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, "chargeItem", name, element, index);
    if (element.hasChargeItemCode()) {
      composeCodeableReference(t, "DeviceDefinitionChargeItemComponent", "chargeItemCode", element.getChargeItemCode(), -1);
    }
    if (element.hasCount()) {
      composeQuantity(t, "DeviceDefinitionChargeItemComponent", "count", element.getCount(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "DeviceDefinitionChargeItemComponent", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "DeviceDefinitionChargeItemComponent", "useContext", element.getUseContext().get(i), i);
    }
  }

  protected void composeDeviceDispense(Complex parent, String parentType, String name, DeviceDispense 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, "DeviceDispense", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceDispense", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "DeviceDispense", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "DeviceDispense", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DeviceDispense", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableReference(t, "DeviceDispense", "statusReason", element.getStatusReason(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DeviceDispense", "category", element.getCategory().get(i), i);
    }
    if (element.hasDevice()) {
      composeCodeableReference(t, "DeviceDispense", "device", element.getDevice(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "DeviceDispense", "subject", element.getSubject(), -1);
    }
    if (element.hasReceiver()) {
      composeReference(t, "DeviceDispense", "receiver", element.getReceiver(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "DeviceDispense", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "DeviceDispense", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeDeviceDispensePerformerComponent(t, "DeviceDispense", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "DeviceDispense", "location", element.getLocation(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "DeviceDispense", "type", element.getType(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "DeviceDispense", "quantity", element.getQuantity(), -1);
    }
    if (element.hasPreparedDateElement()) {
      composeDateTime(t, "DeviceDispense", "preparedDate", element.getPreparedDateElement(), -1);
    }
    if (element.hasWhenHandedOverElement()) {
      composeDateTime(t, "DeviceDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
    }
    if (element.hasDestination()) {
      composeReference(t, "DeviceDispense", "destination", element.getDestination(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DeviceDispense", "note", element.getNote().get(i), i);
    }
    if (element.hasUsageInstructionElement()) {
      composeMarkdown(t, "DeviceDispense", "usageInstruction", element.getUsageInstructionElement(), -1);
    }
    for (int i = 0; i < element.getEventHistory().size(); i++) {
      composeReference(t, "DeviceDispense", "eventHistory", element.getEventHistory().get(i), i);
    }
  }

  protected void composeDeviceDispensePerformerComponent(Complex parent, String parentType, String name, DeviceDispense.DeviceDispensePerformerComponent 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, "DeviceDispensePerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "DeviceDispensePerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric 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, "DeviceMetric", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1);
    }
    if (element.hasUnit()) {
      composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1);
    }
    if (element.hasDevice()) {
      composeReference(t, "DeviceMetric", "device", element.getDevice(), -1);
    }
    if (element.hasOperationalStatusElement()) {
      composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1);
    }
    if (element.hasColorElement()) {
      composeCode(t, "DeviceMetric", "color", element.getColorElement(), -1);
    }
    if (element.hasCategoryElement()) {
      composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1);
    }
    if (element.hasMeasurementFrequency()) {
      composeQuantity(t, "DeviceMetric", "measurementFrequency", element.getMeasurementFrequency(), -1);
    }
    for (int i = 0; i < element.getCalibration().size(); i++) {
      composeDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i);
    }
  }

  protected void composeDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent 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, "calibration", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "DeviceMetricCalibrationComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasStateElement()) {
      composeEnum(t, "DeviceMetricCalibrationComponent", "state", element.getStateElement(), -1);
    }
    if (element.hasTimeElement()) {
      composeInstant(t, "DeviceMetricCalibrationComponent", "time", element.getTimeElement(), -1);
    }
  }

  protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest 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, "DeviceRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "DeviceRequest", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "DeviceRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableReference(t, "DeviceRequest", "code", element.getCode(), -1);
    }
    if (element.hasQuantityElement()) {
      composeInteger(t, "DeviceRequest", "quantity", element.getQuantityElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1);
    }
    if (element.hasPerformer()) {
      composeCodeableReference(t, "DeviceRequest", "performer", element.getPerformer(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "DeviceRequest", "reason", element.getReason().get(i), i);
    }
    if (element.hasAsNeededElement()) {
      composeBoolean(t, "DeviceRequest", "asNeeded", element.getAsNeededElement(), -1);
    }
    if (element.hasAsNeededFor()) {
      composeCodeableConcept(t, "DeviceRequest", "asNeededFor", element.getAsNeededFor(), -1);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
      composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
    }
  }

  protected void composeDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent 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, "parameter", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "DeviceRequestParameterComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "DeviceRequestParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeDeviceUsage(Complex parent, String parentType, String name, DeviceUsage 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, "DeviceUsage", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DeviceUsage", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "DeviceUsage", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DeviceUsage", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DeviceUsage", "category", element.getCategory().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "DeviceUsage", "patient", element.getPatient(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeReference(t, "DeviceUsage", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    if (element.hasContext()) {
      composeReference(t, "DeviceUsage", "context", element.getContext(), -1);
    }
    if (element.hasTiming()) {
      composeType(t, "DeviceUsage", "timing", element.getTiming(), -1);
    }
    if (element.hasDateAssertedElement()) {
      composeDateTime(t, "DeviceUsage", "dateAsserted", element.getDateAssertedElement(), -1);
    }
    if (element.hasUsageStatus()) {
      composeCodeableConcept(t, "DeviceUsage", "usageStatus", element.getUsageStatus(), -1);
    }
    for (int i = 0; i < element.getUsageReason().size(); i++) {
      composeCodeableConcept(t, "DeviceUsage", "usageReason", element.getUsageReason().get(i), i);
    }
    if (element.hasAdherence()) {
      composeDeviceUsageAdherenceComponent(t, "DeviceUsage", "adherence", element.getAdherence(), -1);
    }
    if (element.hasInformationSource()) {
      composeReference(t, "DeviceUsage", "informationSource", element.getInformationSource(), -1);
    }
    if (element.hasDevice()) {
      composeCodeableReference(t, "DeviceUsage", "device", element.getDevice(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "DeviceUsage", "reason", element.getReason().get(i), i);
    }
    if (element.hasBodySite()) {
      composeCodeableReference(t, "DeviceUsage", "bodySite", element.getBodySite(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DeviceUsage", "note", element.getNote().get(i), i);
    }
  }

  protected void composeDeviceUsageAdherenceComponent(Complex parent, String parentType, String name, DeviceUsage.DeviceUsageAdherenceComponent 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, "adherence", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "DeviceUsageAdherenceComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "DeviceUsageAdherenceComponent", "reason", element.getReason().get(i), i);
    }
  }

  protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport 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, "DiagnosticReport", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1);
    }
    if (element.hasEffective()) {
      composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1);
    }
    if (element.hasIssuedElement()) {
      composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getResultsInterpreter().size(); i++) {
      composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i);
    }
    for (int i = 0; i < element.getSpecimen().size(); i++) {
      composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i);
    }
    for (int i = 0; i < element.getResult().size(); i++) {
      composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "DiagnosticReport", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getStudy().size(); i++) {
      composeReference(t, "DiagnosticReport", "study", element.getStudy().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeDiagnosticReportSupportingInfoComponent(t, "DiagnosticReport", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getMedia().size(); i++) {
      composeDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i);
    }
    if (element.hasComposition()) {
      composeReference(t, "DiagnosticReport", "composition", element.getComposition(), -1);
    }
    if (element.hasConclusionElement()) {
      composeMarkdown(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1);
    }
    for (int i = 0; i < element.getConclusionCode().size(); i++) {
      composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i);
    }
    for (int i = 0; i < element.getPresentedForm().size(); i++) {
      composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i);
    }
  }

  protected void composeDiagnosticReportSupportingInfoComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportSupportingInfoComponent 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.hasType()) {
      composeCodeableConcept(t, "DiagnosticReportSupportingInfoComponent", "type", element.getType(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "DiagnosticReportSupportingInfoComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent 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, "media", name, element, index);
    if (element.hasCommentElement()) {
      composeString(t, "DiagnosticReportMediaComponent", "comment", element.getCommentElement(), -1);
    }
    if (element.hasLink()) {
      composeReference(t, "DiagnosticReportMediaComponent", "link", element.getLink(), -1);
    }
  }

  protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference 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, "DocumentReference", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "DocumentReference", "version", element.getVersionElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "DocumentReference", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1);
    }
    if (element.hasDocStatusElement()) {
      composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1);
    }
    for (int i = 0; i < element.getModality().size(); i++) {
      composeCodeableConcept(t, "DocumentReference", "modality", element.getModality().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "DocumentReference", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getContext().size(); i++) {
      composeReference(t, "DocumentReference", "context", element.getContext().get(i), i);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeCodeableReference(t, "DocumentReference", "event", element.getEvent().get(i), i);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeCodeableReference(t, "DocumentReference", "bodySite", element.getBodySite().get(i), i);
    }
    if (element.hasFacilityType()) {
      composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1);
    }
    if (element.hasPracticeSetting()) {
      composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1);
    }
    if (element.hasDateElement()) {
      composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getAttester().size(); i++) {
      composeDocumentReferenceAttesterComponent(t, "DocumentReference", "attester", element.getAttester().get(i), i);
    }
    if (element.hasCustodian()) {
      composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1);
    }
    for (int i = 0; i < element.getRelatesTo().size(); i++) {
      composeDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "DocumentReference", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
      composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i);
    }
    for (int i = 0; i < element.getContent().size(); i++) {
      composeDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i);
    }
  }

  protected void composeDocumentReferenceAttesterComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceAttesterComponent 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, "DocumentReferenceAttesterComponent", "mode", element.getMode(), -1);
    }
    if (element.hasTimeElement()) {
      composeDateTime(t, "DocumentReferenceAttesterComponent", "time", element.getTimeElement(), -1);
    }
    if (element.hasParty()) {
      composeReference(t, "DocumentReferenceAttesterComponent", "party", element.getParty(), -1);
    }
  }

  protected void composeDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent 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.hasCode()) {
      composeCodeableConcept(t, "DocumentReferenceRelatesToComponent", "code", element.getCode(), -1);
    }
    if (element.hasTarget()) {
      composeReference(t, "DocumentReferenceRelatesToComponent", "target", element.getTarget(), -1);
    }
  }

  protected void composeDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent 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.hasAttachment()) {
      composeAttachment(t, "DocumentReferenceContentComponent", "attachment", element.getAttachment(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeDocumentReferenceContentProfileComponent(t, "DocumentReferenceContentComponent", "profile", element.getProfile().get(i), i);
    }
  }

  protected void composeDocumentReferenceContentProfileComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentProfileComponent 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, "profile", name, element, index);
    if (element.hasValue()) {
      composeType(t, "DocumentReferenceContentProfileComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeEncounter(Complex parent, String parentType, String name, Encounter 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, "Encounter", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getClass_().size(); i++) {
      composeCodeableConcept(t, "Encounter", "class", element.getClass_().get(i), i);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getServiceType().size(); i++) {
      composeCodeableReference(t, "Encounter", "serviceType", element.getServiceType().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "Encounter", "subject", element.getSubject(), -1);
    }
    if (element.hasSubjectStatus()) {
      composeCodeableConcept(t, "Encounter", "subjectStatus", element.getSubjectStatus(), -1);
    }
    for (int i = 0; i < element.getEpisodeOfCare().size(); i++) {
      composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getCareTeam().size(); i++) {
      composeReference(t, "Encounter", "careTeam", element.getCareTeam().get(i), i);
    }
    if (element.hasPartOf()) {
      composeReference(t, "Encounter", "partOf", element.getPartOf(), -1);
    }
    if (element.hasServiceProvider()) {
      composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i);
    }
    for (int i = 0; i < element.getAppointment().size(); i++) {
      composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i);
    }
    for (int i = 0; i < element.getVirtualService().size(); i++) {
      composeVirtualServiceDetail(t, "Encounter", "virtualService", element.getVirtualService().get(i), i);
    }
    if (element.hasActualPeriod()) {
      composePeriod(t, "Encounter", "actualPeriod", element.getActualPeriod(), -1);
    }
    if (element.hasPlannedStartDateElement()) {
      composeDateTime(t, "Encounter", "plannedStartDate", element.getPlannedStartDateElement(), -1);
    }
    if (element.hasPlannedEndDateElement()) {
      composeDateTime(t, "Encounter", "plannedEndDate", element.getPlannedEndDateElement(), -1);
    }
    if (element.hasLength()) {
      composeDuration(t, "Encounter", "length", element.getLength(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeEncounterReasonComponent(t, "Encounter", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i);
    }
    for (int i = 0; i < element.getAccount().size(); i++) {
      composeReference(t, "Encounter", "account", element.getAccount().get(i), i);
    }
    for (int i = 0; i < element.getDietPreference().size(); i++) {
      composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i);
    }
    for (int i = 0; i < element.getSpecialArrangement().size(); i++) {
      composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i);
    }
    for (int i = 0; i < element.getSpecialCourtesy().size(); i++) {
      composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i);
    }
    if (element.hasAdmission()) {
      composeEncounterAdmissionComponent(t, "Encounter", "admission", element.getAdmission(), -1);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i);
    }
  }

  protected void composeEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent 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, "EncounterParticipantComponent", "type", element.getType().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "EncounterParticipantComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "EncounterParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeEncounterReasonComponent(Complex parent, String parentType, String name, Encounter.ReasonComponent 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, "reason", name, element, index);
    for (int i = 0; i < element.getUse().size(); i++) {
      composeCodeableConcept(t, "ReasonComponent", "use", element.getUse().get(i), i);
    }
    for (int i = 0; i < element.getValue().size(); i++) {
      composeCodeableReference(t, "ReasonComponent", "value", element.getValue().get(i), i);
    }
  }

  protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.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);
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeCodeableReference(t, "DiagnosisComponent", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getUse().size(); i++) {
      composeCodeableConcept(t, "DiagnosisComponent", "use", element.getUse().get(i), i);
    }
  }

  protected void composeEncounterAdmissionComponent(Complex parent, String parentType, String name, Encounter.EncounterAdmissionComponent 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, "admission", name, element, index);
    if (element.hasPreAdmissionIdentifier()) {
      composeIdentifier(t, "EncounterAdmissionComponent", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1);
    }
    if (element.hasOrigin()) {
      composeReference(t, "EncounterAdmissionComponent", "origin", element.getOrigin(), -1);
    }
    if (element.hasAdmitSource()) {
      composeCodeableConcept(t, "EncounterAdmissionComponent", "admitSource", element.getAdmitSource(), -1);
    }
    if (element.hasReAdmission()) {
      composeCodeableConcept(t, "EncounterAdmissionComponent", "reAdmission", element.getReAdmission(), -1);
    }
    if (element.hasDestination()) {
      composeReference(t, "EncounterAdmissionComponent", "destination", element.getDestination(), -1);
    }
    if (element.hasDischargeDisposition()) {
      composeCodeableConcept(t, "EncounterAdmissionComponent", "dischargeDisposition", element.getDischargeDisposition(), -1);
    }
  }

  protected void composeEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent 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, "location", name, element, index);
    if (element.hasLocation()) {
      composeReference(t, "EncounterLocationComponent", "location", element.getLocation(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EncounterLocationComponent", "status", element.getStatusElement(), -1);
    }
    if (element.hasForm()) {
      composeCodeableConcept(t, "EncounterLocationComponent", "form", element.getForm(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "EncounterLocationComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeEncounterHistory(Complex parent, String parentType, String name, EncounterHistory 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, "EncounterHistory", name, element, index);
    if (element.hasEncounter()) {
      composeReference(t, "EncounterHistory", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EncounterHistory", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EncounterHistory", "status", element.getStatusElement(), -1);
    }
    if (element.hasClass_()) {
      composeCodeableConcept(t, "EncounterHistory", "class", element.getClass_(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "EncounterHistory", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getServiceType().size(); i++) {
      composeCodeableReference(t, "EncounterHistory", "serviceType", element.getServiceType().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "EncounterHistory", "subject", element.getSubject(), -1);
    }
    if (element.hasSubjectStatus()) {
      composeCodeableConcept(t, "EncounterHistory", "subjectStatus", element.getSubjectStatus(), -1);
    }
    if (element.hasActualPeriod()) {
      composePeriod(t, "EncounterHistory", "actualPeriod", element.getActualPeriod(), -1);
    }
    if (element.hasPlannedStartDateElement()) {
      composeDateTime(t, "EncounterHistory", "plannedStartDate", element.getPlannedStartDateElement(), -1);
    }
    if (element.hasPlannedEndDateElement()) {
      composeDateTime(t, "EncounterHistory", "plannedEndDate", element.getPlannedEndDateElement(), -1);
    }
    if (element.hasLength()) {
      composeDuration(t, "EncounterHistory", "length", element.getLength(), -1);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeEncounterHistoryLocationComponent(t, "EncounterHistory", "location", element.getLocation().get(i), i);
    }
  }

  protected void composeEncounterHistoryLocationComponent(Complex parent, String parentType, String name, EncounterHistory.EncounterHistoryLocationComponent 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, "location", name, element, index);
    if (element.hasLocation()) {
      composeReference(t, "EncounterHistoryLocationComponent", "location", element.getLocation(), -1);
    }
    if (element.hasForm()) {
      composeCodeableConcept(t, "EncounterHistoryLocationComponent", "form", element.getForm(), -1);
    }
  }

  protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint 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, "Endpoint", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getConnectionType().size(); i++) {
      composeCodeableConcept(t, "Endpoint", "connectionType", element.getConnectionType().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Endpoint", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "Endpoint", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getEnvironmentType().size(); i++) {
      composeCodeableConcept(t, "Endpoint", "environmentType", element.getEnvironmentType().get(i), i);
    }
    if (element.hasManagingOrganization()) {
      composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Endpoint", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getPayload().size(); i++) {
      composeEndpointPayloadComponent(t, "Endpoint", "payload", element.getPayload().get(i), i);
    }
    if (element.hasAddressElement()) {
      composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1);
    }
    for (int i = 0; i < element.getHeader().size(); i++) {
      composeString(t, "Endpoint", "header", element.getHeader().get(i), i);
    }
  }

  protected void composeEndpointPayloadComponent(Complex parent, String parentType, String name, Endpoint.EndpointPayloadComponent 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);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "EndpointPayloadComponent", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getMimeType().size(); i++) {
      composeCode(t, "EndpointPayloadComponent", "mimeType", element.getMimeType().get(i), i);
    }
  }

  protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest 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, "EnrollmentRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1);
    }
    if (element.hasProvider()) {
      composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1);
    }
    if (element.hasCandidate()) {
      composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1);
    }
    if (element.hasCoverage()) {
      composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1);
    }
  }

  protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse 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, "EnrollmentResponse", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1);
    }
    if (element.hasRequest()) {
      composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1);
    }
    if (element.hasOutcomeElement()) {
      composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1);
    }
    if (element.hasDispositionElement()) {
      composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1);
    }
    if (element.hasRequestProvider()) {
      composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1);
    }
  }

  protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare 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, "EpisodeOfCare", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getStatusHistory().size(); i++) {
      composeEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeEpisodeOfCareReasonComponent(t, "EpisodeOfCare", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1);
    }
    if (element.hasManagingOrganization()) {
      composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getReferralRequest().size(); i++) {
      composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i);
    }
    if (element.hasCareManager()) {
      composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1);
    }
    for (int i = 0; i < element.getCareTeam().size(); i++) {
      composeReference(t, "EpisodeOfCare", "careTeam", element.getCareTeam().get(i), i);
    }
    for (int i = 0; i < element.getAccount().size(); i++) {
      composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i);
    }
  }

  protected void composeEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent 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, "statusHistory", name, element, index);
    if (element.hasStatusElement()) {
      composeEnum(t, "EpisodeOfCareStatusHistoryComponent", "status", element.getStatusElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "EpisodeOfCareStatusHistoryComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeEpisodeOfCareReasonComponent(Complex parent, String parentType, String name, EpisodeOfCare.ReasonComponent 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, "reason", name, element, index);
    if (element.hasUse()) {
      composeCodeableConcept(t, "ReasonComponent", "use", element.getUse(), -1);
    }
    for (int i = 0; i < element.getValue().size(); i++) {
      composeCodeableReference(t, "ReasonComponent", "value", element.getValue().get(i), i);
    }
  }

  protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.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);
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeCodeableReference(t, "DiagnosisComponent", "condition", element.getCondition().get(i), i);
    }
    if (element.hasUse()) {
      composeCodeableConcept(t, "DiagnosisComponent", "use", element.getUse(), -1);
    }
  }

  protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition 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, "EventDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "EventDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "EventDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "EventDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "EventDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "EventDefinition", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasUsageElement()) {
      composeMarkdown(t, "EventDefinition", "usage", element.getUsageElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "EventDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getTrigger().size(); i++) {
      composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i);
    }
  }

  protected void composeEvidence(Complex parent, String parentType, String name, Evidence 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, "Evidence", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Evidence", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Evidence", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Evidence", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Evidence", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Evidence", "title", element.getTitleElement(), -1);
    }
    if (element.hasCiteAs()) {
      composeType(t, "Evidence", "citeAs", element.getCiteAs(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Evidence", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Evidence", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Evidence", "date", element.getDateElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Evidence", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Evidence", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "Evidence", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "Evidence", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "Evidence", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "Evidence", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Evidence", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Evidence", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Evidence", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasAssertionElement()) {
      composeMarkdown(t, "Evidence", "assertion", element.getAssertionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getVariableDefinition().size(); i++) {
      composeEvidenceVariableDefinitionComponent(t, "Evidence", "variableDefinition", element.getVariableDefinition().get(i), i);
    }
    if (element.hasSynthesisType()) {
      composeCodeableConcept(t, "Evidence", "synthesisType", element.getSynthesisType(), -1);
    }
    for (int i = 0; i < element.getStudyDesign().size(); i++) {
      composeCodeableConcept(t, "Evidence", "studyDesign", element.getStudyDesign().get(i), i);
    }
    for (int i = 0; i < element.getStatistic().size(); i++) {
      composeEvidenceStatisticComponent(t, "Evidence", "statistic", element.getStatistic().get(i), i);
    }
    for (int i = 0; i < element.getCertainty().size(); i++) {
      composeEvidenceCertaintyComponent(t, "Evidence", "certainty", element.getCertainty().get(i), i);
    }
  }

  protected void composeEvidenceVariableDefinitionComponent(Complex parent, String parentType, String name, Evidence.EvidenceVariableDefinitionComponent 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, "variableDefinition", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceVariableDefinitionComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceVariableDefinitionComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasVariableRole()) {
      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "variableRole", element.getVariableRole(), -1);
    }
    if (element.hasObserved()) {
      composeReference(t, "EvidenceVariableDefinitionComponent", "observed", element.getObserved(), -1);
    }
    if (element.hasIntended()) {
      composeReference(t, "EvidenceVariableDefinitionComponent", "intended", element.getIntended(), -1);
    }
    if (element.hasDirectnessMatch()) {
      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "directnessMatch", element.getDirectnessMatch(), -1);
    }
  }

  protected void composeEvidenceStatisticComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticComponent 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, "statistic", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceStatisticComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceStatisticComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasStatisticType()) {
      composeCodeableConcept(t, "EvidenceStatisticComponent", "statisticType", element.getStatisticType(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "EvidenceStatisticComponent", "category", element.getCategory(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "EvidenceStatisticComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasNumberOfEventsElement()) {
      composeUnsignedInt(t, "EvidenceStatisticComponent", "numberOfEvents", element.getNumberOfEventsElement(), -1);
    }
    if (element.hasNumberAffectedElement()) {
      composeUnsignedInt(t, "EvidenceStatisticComponent", "numberAffected", element.getNumberAffectedElement(), -1);
    }
    if (element.hasSampleSize()) {
      composeEvidenceStatisticSampleSizeComponent(t, "EvidenceStatisticComponent", "sampleSize", element.getSampleSize(), -1);
    }
    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
    }
    for (int i = 0; i < element.getModelCharacteristic().size(); i++) {
      composeEvidenceStatisticModelCharacteristicComponent(t, "EvidenceStatisticComponent", "modelCharacteristic", element.getModelCharacteristic().get(i), i);
    }
  }

  protected void composeEvidenceStatisticSampleSizeComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticSampleSizeComponent 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, "sampleSize", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceStatisticSampleSizeComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceStatisticSampleSizeComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasNumberOfStudiesElement()) {
      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "numberOfStudies", element.getNumberOfStudiesElement(), -1);
    }
    if (element.hasNumberOfParticipantsElement()) {
      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1);
    }
    if (element.hasKnownDataCountElement()) {
      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "knownDataCount", element.getKnownDataCountElement(), -1);
    }
  }

  protected void composeEvidenceStatisticAttributeEstimateComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticAttributeEstimateComponent 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, "attributeEstimate", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceStatisticAttributeEstimateComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceStatisticAttributeEstimateComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "EvidenceStatisticAttributeEstimateComponent", "type", element.getType(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "EvidenceStatisticAttributeEstimateComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasLevelElement()) {
      composeDecimal(t, "EvidenceStatisticAttributeEstimateComponent", "level", element.getLevelElement(), -1);
    }
    if (element.hasRange()) {
      composeRange(t, "EvidenceStatisticAttributeEstimateComponent", "range", element.getRange(), -1);
    }
    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticAttributeEstimateComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
    }
  }

  protected void composeEvidenceStatisticModelCharacteristicComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticModelCharacteristicComponent 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, "modelCharacteristic", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "EvidenceStatisticModelCharacteristicComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeQuantity(t, "EvidenceStatisticModelCharacteristicComponent", "value", element.getValue(), -1);
    }
    for (int i = 0; i < element.getVariable().size(); i++) {
      composeEvidenceStatisticModelCharacteristicVariableComponent(t, "EvidenceStatisticModelCharacteristicComponent", "variable", element.getVariable().get(i), i);
    }
    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticModelCharacteristicComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
    }
  }

  protected void composeEvidenceStatisticModelCharacteristicVariableComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticModelCharacteristicVariableComponent 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, "variable", name, element, index);
    if (element.hasVariableDefinition()) {
      composeReference(t, "EvidenceStatisticModelCharacteristicVariableComponent", "variableDefinition", element.getVariableDefinition(), -1);
    }
    if (element.hasHandlingElement()) {
      composeEnum(t, "EvidenceStatisticModelCharacteristicVariableComponent", "handling", element.getHandlingElement(), -1);
    }
    for (int i = 0; i < element.getValueCategory().size(); i++) {
      composeCodeableConcept(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueCategory", element.getValueCategory().get(i), i);
    }
    for (int i = 0; i < element.getValueQuantity().size(); i++) {
      composeQuantity(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueQuantity", element.getValueQuantity().get(i), i);
    }
    for (int i = 0; i < element.getValueRange().size(); i++) {
      composeRange(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueRange", element.getValueRange().get(i), i);
    }
  }

  protected void composeEvidenceCertaintyComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyComponent 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, "certainty", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceCertaintyComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceCertaintyComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "EvidenceCertaintyComponent", "type", element.getType(), -1);
    }
    if (element.hasRating()) {
      composeCodeableConcept(t, "EvidenceCertaintyComponent", "rating", element.getRating(), -1);
    }
    if (element.hasRaterElement()) {
      composeString(t, "EvidenceCertaintyComponent", "rater", element.getRaterElement(), -1);
    }
    for (int i = 0; i < element.getSubcomponent().size(); i++) {
      composeEvidenceCertaintyComponent(t, "EvidenceCertaintyComponent", "subcomponent", element.getSubcomponent().get(i), i);
    }
  }

  protected void composeEvidenceReport(Complex parent, String parentType, String name, EvidenceReport 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, "EvidenceReport", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "EvidenceReport", "url", element.getUrlElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EvidenceReport", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "EvidenceReport", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EvidenceReport", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getRelatedIdentifier().size(); i++) {
      composeIdentifier(t, "EvidenceReport", "relatedIdentifier", element.getRelatedIdentifier().get(i), i);
    }
    if (element.hasCiteAs()) {
      composeType(t, "EvidenceReport", "citeAs", element.getCiteAs(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "EvidenceReport", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceReport", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "EvidenceReport", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasSubject()) {
      composeEvidenceReportSubjectComponent(t, "EvidenceReport", "subject", element.getSubject(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "EvidenceReport", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "EvidenceReport", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "EvidenceReport", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "EvidenceReport", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "EvidenceReport", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "EvidenceReport", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatesTo().size(); i++) {
      composeEvidenceReportRelatesToComponent(t, "EvidenceReport", "relatesTo", element.getRelatesTo().get(i), i);
    }
    for (int i = 0; i < element.getSection().size(); i++) {
      composeEvidenceReportSectionComponent(t, "EvidenceReport", "section", element.getSection().get(i), i);
    }
  }

  protected void composeEvidenceReportSubjectComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportSubjectComponent 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.getCharacteristic().size(); i++) {
      composeEvidenceReportSubjectCharacteristicComponent(t, "EvidenceReportSubjectComponent", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceReportSubjectComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeEvidenceReportSubjectCharacteristicComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportSubjectCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "EvidenceReportSubjectCharacteristicComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "EvidenceReportSubjectCharacteristicComponent", "value", element.getValue(), -1);
    }
    if (element.hasExcludeElement()) {
      composeBoolean(t, "EvidenceReportSubjectCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "EvidenceReportSubjectCharacteristicComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeEvidenceReportRelatesToComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportRelatesToComponent 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.hasCodeElement()) {
      composeEnum(t, "EvidenceReportRelatesToComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasTarget()) {
      composeEvidenceReportRelatesToTargetComponent(t, "EvidenceReportRelatesToComponent", "target", element.getTarget(), -1);
    }
  }

  protected void composeEvidenceReportRelatesToTargetComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportRelatesToTargetComponent 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.hasUrlElement()) {
      composeUri(t, "EvidenceReportRelatesToTargetComponent", "url", element.getUrlElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "EvidenceReportRelatesToTargetComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasDisplayElement()) {
      composeMarkdown(t, "EvidenceReportRelatesToTargetComponent", "display", element.getDisplayElement(), -1);
    }
    if (element.hasResource()) {
      composeReference(t, "EvidenceReportRelatesToTargetComponent", "resource", element.getResource(), -1);
    }
  }

  protected void composeEvidenceReportSectionComponent(Complex parent, String parentType, String name, EvidenceReport.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.hasFocus()) {
      composeCodeableConcept(t, "SectionComponent", "focus", element.getFocus(), -1);
    }
    if (element.hasFocusReference()) {
      composeReference(t, "SectionComponent", "focusReference", element.getFocusReference(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
    }
    if (element.hasText()) {
      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
    }
    if (element.hasModeElement()) {
      composeEnum(t, "SectionComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasOrderedBy()) {
      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
    }
    for (int i = 0; i < element.getEntryClassifier().size(); i++) {
      composeCodeableConcept(t, "SectionComponent", "entryClassifier", element.getEntryClassifier().get(i), i);
    }
    for (int i = 0; i < element.getEntryReference().size(); i++) {
      composeReference(t, "SectionComponent", "entryReference", element.getEntryReference().get(i), i);
    }
    for (int i = 0; i < element.getEntryQuantity().size(); i++) {
      composeQuantity(t, "SectionComponent", "entryQuantity", element.getEntryQuantity().get(i), i);
    }
    if (element.hasEmptyReason()) {
      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
    }
    for (int i = 0; i < element.getSection().size(); i++) {
      composeEvidenceReportSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
    }
  }

  protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable 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, "EvidenceVariable", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "EvidenceVariable", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1);
    }
    if (element.hasShortTitleElement()) {
      composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "EvidenceVariable", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "EvidenceVariable", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "EvidenceVariable", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "EvidenceVariable", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "EvidenceVariable", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "EvidenceVariable", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "EvidenceVariable", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasActualElement()) {
      composeBoolean(t, "EvidenceVariable", "actual", element.getActualElement(), -1);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i);
    }
    if (element.hasHandlingElement()) {
      composeEnum(t, "EvidenceVariable", "handling", element.getHandlingElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeEvidenceVariableCategoryComponent(t, "EvidenceVariable", "category", element.getCategory().get(i), i);
    }
  }

  protected void composeEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasLinkIdElement()) {
      composeId(t, "EvidenceVariableCharacteristicComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceVariableCharacteristicComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceVariableCharacteristicComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasExcludeElement()) {
      composeBoolean(t, "EvidenceVariableCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
    }
    if (element.hasDefinitionReference()) {
      composeReference(t, "EvidenceVariableCharacteristicComponent", "definitionReference", element.getDefinitionReference(), -1);
    }
    if (element.hasDefinitionCanonicalElement()) {
      composeCanonical(t, "EvidenceVariableCharacteristicComponent", "definitionCanonical", element.getDefinitionCanonicalElement(), -1);
    }
    if (element.hasDefinitionCodeableConcept()) {
      composeCodeableConcept(t, "EvidenceVariableCharacteristicComponent", "definitionCodeableConcept", element.getDefinitionCodeableConcept(), -1);
    }
    if (element.hasDefinitionExpression()) {
      composeExpression(t, "EvidenceVariableCharacteristicComponent", "definitionExpression", element.getDefinitionExpression(), -1);
    }
    if (element.hasDefinitionIdElement()) {
      composeId(t, "EvidenceVariableCharacteristicComponent", "definitionId", element.getDefinitionIdElement(), -1);
    }
    if (element.hasDefinitionByTypeAndValue()) {
      composeEvidenceVariableCharacteristicDefinitionByTypeAndValueComponent(t, "EvidenceVariableCharacteristicComponent", "definitionByTypeAndValue", element.getDefinitionByTypeAndValue(), -1);
    }
    if (element.hasDefinitionByCombination()) {
      composeEvidenceVariableCharacteristicDefinitionByCombinationComponent(t, "EvidenceVariableCharacteristicComponent", "definitionByCombination", element.getDefinitionByCombination(), -1);
    }
    if (element.hasInstances()) {
      composeType(t, "EvidenceVariableCharacteristicComponent", "instances", element.getInstances(), -1);
    }
    if (element.hasDuration()) {
      composeType(t, "EvidenceVariableCharacteristicComponent", "duration", element.getDuration(), -1);
    }
    for (int i = 0; i < element.getTimeFromEvent().size(); i++) {
      composeEvidenceVariableCharacteristicTimeFromEventComponent(t, "EvidenceVariableCharacteristicComponent", "timeFromEvent", element.getTimeFromEvent().get(i), i);
    }
  }

  protected void composeEvidenceVariableCharacteristicDefinitionByTypeAndValueComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent 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, "definitionByTypeAndValue", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getMethod().size(); i++) {
      composeCodeableConcept(t, "EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent", "method", element.getMethod().get(i), i);
    }
    if (element.hasDevice()) {
      composeReference(t, "EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent", "device", element.getDevice(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent", "value", element.getValue(), -1);
    }
    if (element.hasOffset()) {
      composeCodeableConcept(t, "EvidenceVariableCharacteristicDefinitionByTypeAndValueComponent", "offset", element.getOffset(), -1);
    }
  }

  protected void composeEvidenceVariableCharacteristicDefinitionByCombinationComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicDefinitionByCombinationComponent 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, "definitionByCombination", name, element, index);
    if (element.hasCodeElement()) {
      composeEnum(t, "EvidenceVariableCharacteristicDefinitionByCombinationComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasThresholdElement()) {
      composePositiveInt(t, "EvidenceVariableCharacteristicDefinitionByCombinationComponent", "threshold", element.getThresholdElement(), -1);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeEvidenceVariableCharacteristicComponent(t, "EvidenceVariableCharacteristicDefinitionByCombinationComponent", "characteristic", element.getCharacteristic().get(i), i);
    }
  }

  protected void composeEvidenceVariableCharacteristicTimeFromEventComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicTimeFromEventComponent 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, "timeFromEvent", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "EvidenceVariableCharacteristicTimeFromEventComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "EvidenceVariableCharacteristicTimeFromEventComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasEvent()) {
      composeType(t, "EvidenceVariableCharacteristicTimeFromEventComponent", "event", element.getEvent(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "EvidenceVariableCharacteristicTimeFromEventComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasRange()) {
      composeRange(t, "EvidenceVariableCharacteristicTimeFromEventComponent", "range", element.getRange(), -1);
    }
  }

  protected void composeEvidenceVariableCategoryComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCategoryComponent 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, "category", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "EvidenceVariableCategoryComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "EvidenceVariableCategoryComponent", "value", element.getValue(), -1);
    }
  }

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

  protected void composeExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent 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.hasKeyElement()) {
      composeString(t, "ExampleScenarioActorComponent", "key", element.getKeyElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "ExampleScenarioActorComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioActorComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioActorComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent 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, "instance", name, element, index);
    if (element.hasKeyElement()) {
      composeString(t, "ExampleScenarioInstanceComponent", "key", element.getKeyElement(), -1);
    }
    if (element.hasStructureType()) {
      composeCoding(t, "ExampleScenarioInstanceComponent", "structureType", element.getStructureType(), -1);
    }
    if (element.hasStructureVersionElement()) {
      composeString(t, "ExampleScenarioInstanceComponent", "structureVersion", element.getStructureVersionElement(), -1);
    }
    if (element.hasStructureProfile()) {
      composeType(t, "ExampleScenarioInstanceComponent", "structureProfile", element.getStructureProfile(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioInstanceComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioInstanceComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasContent()) {
      composeReference(t, "ExampleScenarioInstanceComponent", "content", element.getContent(), -1);
    }
    for (int i = 0; i < element.getVersion().size(); i++) {
      composeExampleScenarioInstanceVersionComponent(t, "ExampleScenarioInstanceComponent", "version", element.getVersion().get(i), i);
    }
    for (int i = 0; i < element.getContainedInstance().size(); i++) {
      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioInstanceComponent", "containedInstance", element.getContainedInstance().get(i), i);
    }
  }

  protected void composeExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent 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.hasKeyElement()) {
      composeString(t, "ExampleScenarioInstanceVersionComponent", "key", element.getKeyElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioInstanceVersionComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioInstanceVersionComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasContent()) {
      composeReference(t, "ExampleScenarioInstanceVersionComponent", "content", element.getContent(), -1);
    }
  }

  protected void composeExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent 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, "containedInstance", name, element, index);
    if (element.hasInstanceReferenceElement()) {
      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "instanceReference", element.getInstanceReferenceElement(), -1);
    }
    if (element.hasVersionReferenceElement()) {
      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "versionReference", element.getVersionReferenceElement(), -1);
    }
  }

  protected void composeExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent 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, "process", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioProcessComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioProcessComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasPreConditionsElement()) {
      composeMarkdown(t, "ExampleScenarioProcessComponent", "preConditions", element.getPreConditionsElement(), -1);
    }
    if (element.hasPostConditionsElement()) {
      composeMarkdown(t, "ExampleScenarioProcessComponent", "postConditions", element.getPostConditionsElement(), -1);
    }
    for (int i = 0; i < element.getStep().size(); i++) {
      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessComponent", "step", element.getStep().get(i), i);
    }
  }

  protected void composeExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent 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, "step", name, element, index);
    if (element.hasNumberElement()) {
      composeString(t, "ExampleScenarioProcessStepComponent", "number", element.getNumberElement(), -1);
    }
    if (element.hasProcess()) {
      composeExampleScenarioProcessComponent(t, "ExampleScenarioProcessStepComponent", "process", element.getProcess(), -1);
    }
    if (element.hasWorkflowElement()) {
      composeCanonical(t, "ExampleScenarioProcessStepComponent", "workflow", element.getWorkflowElement(), -1);
    }
    if (element.hasOperation()) {
      composeExampleScenarioProcessStepOperationComponent(t, "ExampleScenarioProcessStepComponent", "operation", element.getOperation(), -1);
    }
    for (int i = 0; i < element.getAlternative().size(); i++) {
      composeExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenarioProcessStepComponent", "alternative", element.getAlternative().get(i), i);
    }
    if (element.hasPauseElement()) {
      composeBoolean(t, "ExampleScenarioProcessStepComponent", "pause", element.getPauseElement(), -1);
    }
  }

  protected void composeExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent 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.hasType()) {
      composeCoding(t, "ExampleScenarioProcessStepOperationComponent", "type", element.getType(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioProcessStepOperationComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasInitiatorElement()) {
      composeString(t, "ExampleScenarioProcessStepOperationComponent", "initiator", element.getInitiatorElement(), -1);
    }
    if (element.hasReceiverElement()) {
      composeString(t, "ExampleScenarioProcessStepOperationComponent", "receiver", element.getReceiverElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioProcessStepOperationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasInitiatorActiveElement()) {
      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "initiatorActive", element.getInitiatorActiveElement(), -1);
    }
    if (element.hasReceiverActiveElement()) {
      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "receiverActive", element.getReceiverActiveElement(), -1);
    }
    if (element.hasRequest()) {
      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "request", element.getRequest(), -1);
    }
    if (element.hasResponse()) {
      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "response", element.getResponse(), -1);
    }
  }

  protected void composeExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent 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, "alternative", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "ExampleScenarioProcessStepAlternativeComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ExampleScenarioProcessStepAlternativeComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getStep().size(); i++) {
      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessStepAlternativeComponent", "step", element.getStep().get(i), i);
    }
  }

  protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit 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, "ExplanationOfBenefit", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ExplanationOfBenefit", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
    }
    if (element.hasSubType()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1);
    }
    if (element.hasBillablePeriod()) {
      composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1);
    }
    if (element.hasEnterer()) {
      composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1);
    }
    if (element.hasInsurer()) {
      composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1);
    }
    if (element.hasProvider()) {
      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1);
    }
    if (element.hasFundsReserveRequested()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1);
    }
    if (element.hasFundsReserve()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1);
    }
    for (int i = 0; i < element.getRelated().size(); i++) {
      composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i);
    }
    if (element.hasPrescription()) {
      composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1);
    }
    if (element.hasOriginalPrescription()) {
      composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1);
    }
    for (int i = 0; i < element.getEvent().size(); i++) {
      composeExplanationOfBenefitEventComponent(t, "ExplanationOfBenefit", "event", element.getEvent().get(i), i);
    }
    if (element.hasPayee()) {
      composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1);
    }
    if (element.hasReferral()) {
      composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1);
    }
    for (int i = 0; i < element.getEncounter().size(); i++) {
      composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i);
    }
    if (element.hasFacility()) {
      composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1);
    }
    if (element.hasClaim()) {
      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
    }
    if (element.hasClaimResponse()) {
      composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1);
    }
    if (element.hasOutcomeElement()) {
      composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1);
    }
    if (element.hasDecision()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "decision", element.getDecision(), -1);
    }
    if (element.hasDispositionElement()) {
      composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1);
    }
    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
    }
    for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++) {
      composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i);
    }
    if (element.hasDiagnosisRelatedGroup()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1);
    }
    for (int i = 0; i < element.getCareTeam().size(); i++) {
      composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getDiagnosis().size(); i++) {
      composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i);
    }
    for (int i = 0; i < element.getProcedure().size(); i++) {
      composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i);
    }
    if (element.hasPrecedenceElement()) {
      composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i);
    }
    if (element.hasAccident()) {
      composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "ExplanationOfBenefit", "patientPaid", element.getPatientPaid(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i);
    }
    for (int i = 0; i < element.getAddItem().size(); i++) {
      composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getTotal().size(); i++) {
      composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i);
    }
    if (element.hasPayment()) {
      composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1);
    }
    if (element.hasFormCode()) {
      composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1);
    }
    if (element.hasForm()) {
      composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1);
    }
    for (int i = 0; i < element.getProcessNote().size(); i++) {
      composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i);
    }
    if (element.hasBenefitPeriod()) {
      composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1);
    }
    for (int i = 0; i < element.getBenefitBalance().size(); i++) {
      composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitEventComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ExplanationOfBenefitEventComponent 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, "ExplanationOfBenefitEventComponent", "type", element.getType(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "ExplanationOfBenefitEventComponent", "when", element.getWhen(), -1);
    }
  }

  protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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()) {
      composeCoding(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
    }
  }

  protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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);
    }
    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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.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);
    }
    for (int i = 0; i < element.getTraceNumber().size(); i++) {
      composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().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++) {
      composeExplanationOfBenefitItemBodySiteComponent(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.getNoteNumber().size(); i++) {
      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "ItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeExplanationOfBenefitDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitItemBodySiteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemBodySiteComponent 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, "ItemBodySiteComponent", "site", element.getSite().get(i), i);
    }
    for (int i = 0; i < element.getSubSite().size(); i++) {
      composeCodeableConcept(t, "ItemBodySiteComponent", "subSite", element.getSubSite().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitItemReviewOutcomeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemReviewOutcomeComponent 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, "ItemReviewOutcomeComponent", "decision", element.getDecision(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "ItemReviewOutcomeComponent", "reason", element.getReason().get(i), i);
    }
    if (element.hasPreAuthRefElement()) {
      composeString(t, "ItemReviewOutcomeComponent", "preAuthRef", element.getPreAuthRefElement(), -1);
    }
    if (element.hasPreAuthPeriod()) {
      composePeriod(t, "ItemReviewOutcomeComponent", "preAuthPeriod", element.getPreAuthPeriod(), -1);
    }
  }

  protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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.getNoteNumber().size(); i++) {
      composePositiveInt(t, "DetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "DetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "DetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getSubDetail().size(); i++) {
      composeExplanationOfBenefitSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "SubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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.hasPatientPaid()) {
      composeMoney(t, "AddedItemComponent", "patientPaid", element.getPatientPaid(), -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++) {
      composeExplanationOfBenefitAddedItemBodySiteComponent(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()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "AddedItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getDetail().size(); i++) {
      composeExplanationOfBenefitAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitAddedItemBodySiteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemBodySiteComponent 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, "AddedItemBodySiteComponent", "site", element.getSite().get(i), i);
    }
    for (int i = 0; i < element.getSubSite().size(); i++) {
      composeCodeableConcept(t, "AddedItemBodySiteComponent", "subSite", element.getSubSite().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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.hasPatientPaid()) {
      composeMoney(t, "AddedItemDetailComponent", "patientPaid", element.getPatientPaid(), -1);
    }
    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()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "AddedItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
    for (int i = 0; i < element.getSubDetail().size(); i++) {
      composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent 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, "AddedItemDetailSubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
    }
    if (element.hasRevenue()) {
      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "revenue", element.getRevenue(), -1);
    }
    if (element.hasProductOrService()) {
      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "productOrService", element.getProductOrService(), -1);
    }
    if (element.hasProductOrServiceEnd()) {
      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "modifier", element.getModifier().get(i), i);
    }
    if (element.hasPatientPaid()) {
      composeMoney(t, "AddedItemDetailSubDetailComponent", "patientPaid", element.getPatientPaid(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "AddedItemDetailSubDetailComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasUnitPrice()) {
      composeMoney(t, "AddedItemDetailSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
    }
    if (element.hasFactorElement()) {
      composeDecimal(t, "AddedItemDetailSubDetailComponent", "factor", element.getFactorElement(), -1);
    }
    if (element.hasTax()) {
      composeMoney(t, "AddedItemDetailSubDetailComponent", "tax", element.getTax(), -1);
    }
    if (element.hasNet()) {
      composeMoney(t, "AddedItemDetailSubDetailComponent", "net", element.getNet(), -1);
    }
    for (int i = 0; i < element.getNoteNumber().size(); i++) {
      composePositiveInt(t, "AddedItemDetailSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
    }
    if (element.hasReviewOutcome()) {
      composeExplanationOfBenefitItemReviewOutcomeComponent(t, "AddedItemDetailSubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
    }
    for (int i = 0; i < element.getAdjudication().size(); i++) {
      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.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 composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent 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, "benefitBalance", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "BenefitBalanceComponent", "category", element.getCategory(), -1);
    }
    if (element.hasExcludedElement()) {
      composeBoolean(t, "BenefitBalanceComponent", "excluded", element.getExcludedElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "BenefitBalanceComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "BenefitBalanceComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasNetwork()) {
      composeCodeableConcept(t, "BenefitBalanceComponent", "network", element.getNetwork(), -1);
    }
    if (element.hasUnit()) {
      composeCodeableConcept(t, "BenefitBalanceComponent", "unit", element.getUnit(), -1);
    }
    if (element.hasTerm()) {
      composeCodeableConcept(t, "BenefitBalanceComponent", "term", element.getTerm(), -1);
    }
    for (int i = 0; i < element.getFinancial().size(); i++) {
      composeExplanationOfBenefitBenefitComponent(t, "BenefitBalanceComponent", "financial", element.getFinancial().get(i), i);
    }
  }

  protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent 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, "financial", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
    }
    if (element.hasAllowed()) {
      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
    }
    if (element.hasUsed()) {
      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
    }
  }

  protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory 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, "FamilyMemberHistory", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1);
    }
    if (element.hasDataAbsentReason()) {
      composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeFamilyMemberHistoryParticipantComponent(t, "FamilyMemberHistory", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1);
    }
    if (element.hasRelationship()) {
      composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1);
    }
    if (element.hasSex()) {
      composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1);
    }
    if (element.hasBorn()) {
      composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1);
    }
    if (element.hasAge()) {
      composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1);
    }
    if (element.hasEstimatedAgeElement()) {
      composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1);
    }
    if (element.hasDeceased()) {
      composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "FamilyMemberHistory", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getProcedure().size(); i++) {
      composeFamilyMemberHistoryProcedureComponent(t, "FamilyMemberHistory", "procedure", element.getProcedure().get(i), i);
    }
  }

  protected void composeFamilyMemberHistoryParticipantComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryParticipantComponent 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, "FamilyMemberHistoryParticipantComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "FamilyMemberHistoryParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent 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, "condition", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "code", element.getCode(), -1);
    }
    if (element.hasOutcome()) {
      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "outcome", element.getOutcome(), -1);
    }
    if (element.hasContributedToDeathElement()) {
      composeBoolean(t, "FamilyMemberHistoryConditionComponent", "contributedToDeath", element.getContributedToDeathElement(), -1);
    }
    if (element.hasOnset()) {
      composeType(t, "FamilyMemberHistoryConditionComponent", "onset", element.getOnset(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "FamilyMemberHistoryConditionComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeFamilyMemberHistoryProcedureComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryProcedureComponent 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.hasCode()) {
      composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "code", element.getCode(), -1);
    }
    if (element.hasOutcome()) {
      composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "outcome", element.getOutcome(), -1);
    }
    if (element.hasContributedToDeathElement()) {
      composeBoolean(t, "FamilyMemberHistoryProcedureComponent", "contributedToDeath", element.getContributedToDeathElement(), -1);
    }
    if (element.hasPerformed()) {
      composeType(t, "FamilyMemberHistoryProcedureComponent", "performed", element.getPerformed(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "FamilyMemberHistoryProcedureComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeFlag(Complex parent, String parentType, String name, Flag 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, "Flag", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Flag", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Flag", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Flag", "subject", element.getSubject(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "Flag", "period", element.getPeriod(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Flag", "encounter", element.getEncounter(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "Flag", "author", element.getAuthor(), -1);
    }
  }

  protected void composeFormularyItem(Complex parent, String parentType, String name, FormularyItem 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, "FormularyItem", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "FormularyItem", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "FormularyItem", "code", element.getCode(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "FormularyItem", "status", element.getStatusElement(), -1);
    }
  }

  protected void composeGenomicStudy(Complex parent, String parentType, String name, GenomicStudy 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, "GenomicStudy", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "GenomicStudy", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "GenomicStudy", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "GenomicStudy", "type", element.getType().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "GenomicStudy", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "GenomicStudy", "encounter", element.getEncounter(), -1);
    }
    if (element.hasStartDateElement()) {
      composeDateTime(t, "GenomicStudy", "startDate", element.getStartDateElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "GenomicStudy", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasReferrer()) {
      composeReference(t, "GenomicStudy", "referrer", element.getReferrer(), -1);
    }
    for (int i = 0; i < element.getInterpreter().size(); i++) {
      composeReference(t, "GenomicStudy", "interpreter", element.getInterpreter().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "GenomicStudy", "reason", element.getReason().get(i), i);
    }
    if (element.hasInstantiatesCanonicalElement()) {
      composeCanonical(t, "GenomicStudy", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
    }
    if (element.hasInstantiatesUriElement()) {
      composeUri(t, "GenomicStudy", "instantiatesUri", element.getInstantiatesUriElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "GenomicStudy", "note", element.getNote().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "GenomicStudy", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getAnalysis().size(); i++) {
      composeGenomicStudyAnalysisComponent(t, "GenomicStudy", "analysis", element.getAnalysis().get(i), i);
    }
  }

  protected void composeGenomicStudyAnalysisComponent(Complex parent, String parentType, String name, GenomicStudy.GenomicStudyAnalysisComponent 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, "analysis", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "GenomicStudyAnalysisComponent", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getMethodType().size(); i++) {
      composeCodeableConcept(t, "GenomicStudyAnalysisComponent", "methodType", element.getMethodType().get(i), i);
    }
    for (int i = 0; i < element.getChangeType().size(); i++) {
      composeCodeableConcept(t, "GenomicStudyAnalysisComponent", "changeType", element.getChangeType().get(i), i);
    }
    if (element.hasGenomeBuild()) {
      composeCodeableConcept(t, "GenomicStudyAnalysisComponent", "genomeBuild", element.getGenomeBuild(), -1);
    }
    if (element.hasInstantiatesCanonicalElement()) {
      composeCanonical(t, "GenomicStudyAnalysisComponent", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
    }
    if (element.hasInstantiatesUriElement()) {
      composeUri(t, "GenomicStudyAnalysisComponent", "instantiatesUri", element.getInstantiatesUriElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "GenomicStudyAnalysisComponent", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "GenomicStudyAnalysisComponent", "focus", element.getFocus().get(i), i);
    }
    for (int i = 0; i < element.getSpecimen().size(); i++) {
      composeReference(t, "GenomicStudyAnalysisComponent", "specimen", element.getSpecimen().get(i), i);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "GenomicStudyAnalysisComponent", "date", element.getDateElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "GenomicStudyAnalysisComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasProtocolPerformed()) {
      composeReference(t, "GenomicStudyAnalysisComponent", "protocolPerformed", element.getProtocolPerformed(), -1);
    }
    for (int i = 0; i < element.getRegionsStudied().size(); i++) {
      composeReference(t, "GenomicStudyAnalysisComponent", "regionsStudied", element.getRegionsStudied().get(i), i);
    }
    for (int i = 0; i < element.getRegionsCalled().size(); i++) {
      composeReference(t, "GenomicStudyAnalysisComponent", "regionsCalled", element.getRegionsCalled().get(i), i);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composeGenomicStudyAnalysisInputComponent(t, "GenomicStudyAnalysisComponent", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getOutput().size(); i++) {
      composeGenomicStudyAnalysisOutputComponent(t, "GenomicStudyAnalysisComponent", "output", element.getOutput().get(i), i);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeGenomicStudyAnalysisPerformerComponent(t, "GenomicStudyAnalysisComponent", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeGenomicStudyAnalysisDeviceComponent(t, "GenomicStudyAnalysisComponent", "device", element.getDevice().get(i), i);
    }
  }

  protected void composeGenomicStudyAnalysisInputComponent(Complex parent, String parentType, String name, GenomicStudy.GenomicStudyAnalysisInputComponent 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, "input", name, element, index);
    if (element.hasFile()) {
      composeReference(t, "GenomicStudyAnalysisInputComponent", "file", element.getFile(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "GenomicStudyAnalysisInputComponent", "type", element.getType(), -1);
    }
    if (element.hasGeneratedBy()) {
      composeType(t, "GenomicStudyAnalysisInputComponent", "generatedBy", element.getGeneratedBy(), -1);
    }
  }

  protected void composeGenomicStudyAnalysisOutputComponent(Complex parent, String parentType, String name, GenomicStudy.GenomicStudyAnalysisOutputComponent 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, "output", name, element, index);
    if (element.hasFile()) {
      composeReference(t, "GenomicStudyAnalysisOutputComponent", "file", element.getFile(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "GenomicStudyAnalysisOutputComponent", "type", element.getType(), -1);
    }
  }

  protected void composeGenomicStudyAnalysisPerformerComponent(Complex parent, String parentType, String name, GenomicStudy.GenomicStudyAnalysisPerformerComponent 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.hasActor()) {
      composeReference(t, "GenomicStudyAnalysisPerformerComponent", "actor", element.getActor(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "GenomicStudyAnalysisPerformerComponent", "role", element.getRole(), -1);
    }
  }

  protected void composeGenomicStudyAnalysisDeviceComponent(Complex parent, String parentType, String name, GenomicStudy.GenomicStudyAnalysisDeviceComponent 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, "device", name, element, index);
    if (element.hasDevice()) {
      composeReference(t, "GenomicStudyAnalysisDeviceComponent", "device", element.getDevice(), -1);
    }
    if (element.hasFunction()) {
      composeCodeableConcept(t, "GenomicStudyAnalysisDeviceComponent", "function", element.getFunction(), -1);
    }
  }

  protected void composeGoal(Complex parent, String parentType, String name, Goal 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, "Goal", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasLifecycleStatusElement()) {
      composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1);
    }
    if (element.hasAchievementStatus()) {
      composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i);
    }
    if (element.hasContinuousElement()) {
      composeBoolean(t, "Goal", "continuous", element.getContinuousElement(), -1);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1);
    }
    if (element.hasDescription()) {
      composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Goal", "subject", element.getSubject(), -1);
    }
    if (element.hasStart()) {
      composeType(t, "Goal", "start", element.getStart(), -1);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i);
    }
    if (element.hasStatusDateElement()) {
      composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1);
    }
    if (element.hasStatusReasonElement()) {
      composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1);
    }
    if (element.hasSource()) {
      composeReference(t, "Goal", "source", element.getSource(), -1);
    }
    for (int i = 0; i < element.getAddresses().size(); i++) {
      composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Goal", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getOutcome().size(); i++) {
      composeCodeableReference(t, "Goal", "outcome", element.getOutcome().get(i), i);
    }
  }

  protected void composeGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent 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.hasMeasure()) {
      composeCodeableConcept(t, "GoalTargetComponent", "measure", element.getMeasure(), -1);
    }
    if (element.hasDetail()) {
      composeType(t, "GoalTargetComponent", "detail", element.getDetail(), -1);
    }
    if (element.hasDue()) {
      composeType(t, "GoalTargetComponent", "due", element.getDue(), -1);
    }
  }

  protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition 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, "GraphDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "GraphDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "GraphDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "GraphDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "GraphDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "GraphDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "GraphDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasStartElement()) {
      composeId(t, "GraphDefinition", "start", element.getStartElement(), -1);
    }
    for (int i = 0; i < element.getNode().size(); i++) {
      composeGraphDefinitionNodeComponent(t, "GraphDefinition", "node", element.getNode().get(i), i);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composeGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
    }
  }

  protected void composeGraphDefinitionNodeComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionNodeComponent 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, "node", name, element, index);
    if (element.hasNodeIdElement()) {
      composeId(t, "GraphDefinitionNodeComponent", "nodeId", element.getNodeIdElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "GraphDefinitionNodeComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "GraphDefinitionNodeComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "GraphDefinitionNodeComponent", "profile", element.getProfileElement(), -1);
    }
  }

  protected void composeGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent 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.hasDescriptionElement()) {
      composeString(t, "GraphDefinitionLinkComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasMinElement()) {
      composeInteger(t, "GraphDefinitionLinkComponent", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "GraphDefinitionLinkComponent", "max", element.getMaxElement(), -1);
    }
    if (element.hasSourceIdElement()) {
      composeId(t, "GraphDefinitionLinkComponent", "sourceId", element.getSourceIdElement(), -1);
    }
    if (element.hasPathElement()) {
      composeString(t, "GraphDefinitionLinkComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasSliceNameElement()) {
      composeString(t, "GraphDefinitionLinkComponent", "sliceName", element.getSliceNameElement(), -1);
    }
    if (element.hasTargetIdElement()) {
      composeId(t, "GraphDefinitionLinkComponent", "targetId", element.getTargetIdElement(), -1);
    }
    if (element.hasParamsElement()) {
      composeString(t, "GraphDefinitionLinkComponent", "params", element.getParamsElement(), -1);
    }
    for (int i = 0; i < element.getCompartment().size(); i++) {
      composeGraphDefinitionLinkCompartmentComponent(t, "GraphDefinitionLinkComponent", "compartment", element.getCompartment().get(i), i);
    }
  }

  protected void composeGraphDefinitionLinkCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkCompartmentComponent 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, "compartment", name, element, index);
    if (element.hasUseElement()) {
      composeEnum(t, "GraphDefinitionLinkCompartmentComponent", "use", element.getUseElement(), -1);
    }
    if (element.hasRuleElement()) {
      composeEnum(t, "GraphDefinitionLinkCompartmentComponent", "rule", element.getRuleElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeEnum(t, "GraphDefinitionLinkCompartmentComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "GraphDefinitionLinkCompartmentComponent", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "GraphDefinitionLinkCompartmentComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeGroup(Complex parent, String parentType, String name, Group 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, "Group", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Group", "active", element.getActiveElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "Group", "type", element.getTypeElement(), -1);
    }
    if (element.hasMembershipElement()) {
      composeEnum(t, "Group", "membership", element.getMembershipElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Group", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Group", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasQuantityElement()) {
      composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1);
    }
    if (element.hasManagingEntity()) {
      composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getMember().size(); i++) {
      composeGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i);
    }
  }

  protected void composeGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "GroupCharacteristicComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "GroupCharacteristicComponent", "value", element.getValue(), -1);
    }
    if (element.hasExcludeElement()) {
      composeBoolean(t, "GroupCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "GroupCharacteristicComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent 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, "member", name, element, index);
    if (element.hasEntity()) {
      composeReference(t, "GroupMemberComponent", "entity", element.getEntity(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "GroupMemberComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasInactiveElement()) {
      composeBoolean(t, "GroupMemberComponent", "inactive", element.getInactiveElement(), -1);
    }
  }

  protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse 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, "GuidanceResponse", name, element, index);
    if (element.hasRequestIdentifier()) {
      composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasModule()) {
      composeType(t, "GuidanceResponse", "module", element.getModule(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrenceDateTimeElement()) {
      composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1);
    }
    if (element.hasPerformer()) {
      composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "GuidanceResponse", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i);
    }
    if (element.hasEvaluationMessage()) {
      composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage(), -1);
    }
    if (element.hasOutputParameters()) {
      composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1);
    }
    for (int i = 0; i < element.getResult().size(); i++) {
      composeReference(t, "GuidanceResponse", "result", element.getResult().get(i), i);
    }
    for (int i = 0; i < element.getDataRequirement().size(); i++) {
      composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i);
    }
  }

  protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService 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, "HealthcareService", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1);
    }
    if (element.hasProvidedBy()) {
      composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1);
    }
    for (int i = 0; i < element.getOfferedIn().size(); i++) {
      composeReference(t, "HealthcareService", "offeredIn", element.getOfferedIn().get(i), i);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "HealthcareService", "name", element.getNameElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "HealthcareService", "comment", element.getCommentElement(), -1);
    }
    if (element.hasExtraDetailsElement()) {
      composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1);
    }
    if (element.hasPhoto()) {
      composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "HealthcareService", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getCoverageArea().size(); i++) {
      composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i);
    }
    for (int i = 0; i < element.getServiceProvisionCode().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i);
    }
    for (int i = 0; i < element.getEligibility().size(); i++) {
      composeHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i);
    }
    for (int i = 0; i < element.getProgram().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i);
    }
    for (int i = 0; i < element.getReferralMethod().size(); i++) {
      composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i);
    }
    if (element.hasAppointmentRequiredElement()) {
      composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1);
    }
    for (int i = 0; i < element.getAvailability().size(); i++) {
      composeAvailability(t, "HealthcareService", "availability", element.getAvailability().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i);
    }
  }

  protected void composeHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent 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, "eligibility", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "HealthcareServiceEligibilityComponent", "code", element.getCode(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "HealthcareServiceEligibilityComponent", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeImagingSelection(Complex parent, String parentType, String name, ImagingSelection 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, "ImagingSelection", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ImagingSelection", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ImagingSelection", "status", element.getStatusElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "ImagingSelection", "subject", element.getSubject(), -1);
    }
    if (element.hasIssuedElement()) {
      composeInstant(t, "ImagingSelection", "issued", element.getIssuedElement(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeImagingSelectionPerformerComponent(t, "ImagingSelection", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "ImagingSelection", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "ImagingSelection", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ImagingSelection", "code", element.getCode(), -1);
    }
    if (element.hasStudyUidElement()) {
      composeId(t, "ImagingSelection", "studyUid", element.getStudyUidElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeReference(t, "ImagingSelection", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "ImagingSelection", "endpoint", element.getEndpoint().get(i), i);
    }
    if (element.hasSeriesUidElement()) {
      composeId(t, "ImagingSelection", "seriesUid", element.getSeriesUidElement(), -1);
    }
    if (element.hasSeriesNumberElement()) {
      composeUnsignedInt(t, "ImagingSelection", "seriesNumber", element.getSeriesNumberElement(), -1);
    }
    if (element.hasFrameOfReferenceUidElement()) {
      composeId(t, "ImagingSelection", "frameOfReferenceUid", element.getFrameOfReferenceUidElement(), -1);
    }
    if (element.hasBodySite()) {
      composeCodeableReference(t, "ImagingSelection", "bodySite", element.getBodySite(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "ImagingSelection", "focus", element.getFocus().get(i), i);
    }
    for (int i = 0; i < element.getInstance().size(); i++) {
      composeImagingSelectionInstanceComponent(t, "ImagingSelection", "instance", element.getInstance().get(i), i);
    }
  }

  protected void composeImagingSelectionPerformerComponent(Complex parent, String parentType, String name, ImagingSelection.ImagingSelectionPerformerComponent 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, "ImagingSelectionPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ImagingSelectionPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeImagingSelectionInstanceComponent(Complex parent, String parentType, String name, ImagingSelection.ImagingSelectionInstanceComponent 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, "instance", name, element, index);
    if (element.hasUidElement()) {
      composeId(t, "ImagingSelectionInstanceComponent", "uid", element.getUidElement(), -1);
    }
    if (element.hasNumberElement()) {
      composeUnsignedInt(t, "ImagingSelectionInstanceComponent", "number", element.getNumberElement(), -1);
    }
    if (element.hasSopClass()) {
      composeCoding(t, "ImagingSelectionInstanceComponent", "sopClass", element.getSopClass(), -1);
    }
    for (int i = 0; i < element.getSubset().size(); i++) {
      composeString(t, "ImagingSelectionInstanceComponent", "subset", element.getSubset().get(i), i);
    }
    for (int i = 0; i < element.getImageRegion2D().size(); i++) {
      composeImagingSelectionImageRegion2DComponent(t, "ImagingSelectionInstanceComponent", "imageRegion2D", element.getImageRegion2D().get(i), i);
    }
    for (int i = 0; i < element.getImageRegion3D().size(); i++) {
      composeImagingSelectionImageRegion3DComponent(t, "ImagingSelectionInstanceComponent", "imageRegion3D", element.getImageRegion3D().get(i), i);
    }
  }

  protected void composeImagingSelectionImageRegion2DComponent(Complex parent, String parentType, String name, ImagingSelection.ImageRegion2DComponent 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, "imageRegion2D", name, element, index);
    if (element.hasRegionTypeElement()) {
      composeEnum(t, "ImageRegion2DComponent", "regionType", element.getRegionTypeElement(), -1);
    }
    for (int i = 0; i < element.getCoordinate().size(); i++) {
      composeDecimal(t, "ImageRegion2DComponent", "coordinate", element.getCoordinate().get(i), i);
    }
  }

  protected void composeImagingSelectionImageRegion3DComponent(Complex parent, String parentType, String name, ImagingSelection.ImageRegion3DComponent 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, "imageRegion3D", name, element, index);
    if (element.hasRegionTypeElement()) {
      composeEnum(t, "ImageRegion3DComponent", "regionType", element.getRegionTypeElement(), -1);
    }
    for (int i = 0; i < element.getCoordinate().size(); i++) {
      composeDecimal(t, "ImageRegion3DComponent", "coordinate", element.getCoordinate().get(i), i);
    }
  }

  protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy 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, "ImagingStudy", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getModality().size(); i++) {
      composeCodeableConcept(t, "ImagingStudy", "modality", element.getModality().get(i), i);
    }
    if (element.hasSubject()) {
      composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1);
    }
    if (element.hasStartedElement()) {
      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "ImagingStudy", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasReferrer()) {
      composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
    }
    if (element.hasNumberOfSeriesElement()) {
      composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1);
    }
    if (element.hasNumberOfInstancesElement()) {
      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
    }
    for (int i = 0; i < element.getProcedure().size(); i++) {
      composeCodeableReference(t, "ImagingStudy", "procedure", element.getProcedure().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "ImagingStudy", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "ImagingStudy", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getSeries().size(); i++) {
      composeImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i);
    }
  }

  protected void composeImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent 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, "series", name, element, index);
    if (element.hasUidElement()) {
      composeId(t, "ImagingStudySeriesComponent", "uid", element.getUidElement(), -1);
    }
    if (element.hasNumberElement()) {
      composeUnsignedInt(t, "ImagingStudySeriesComponent", "number", element.getNumberElement(), -1);
    }
    if (element.hasModality()) {
      composeCodeableConcept(t, "ImagingStudySeriesComponent", "modality", element.getModality(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "ImagingStudySeriesComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasNumberOfInstancesElement()) {
      composeUnsignedInt(t, "ImagingStudySeriesComponent", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "ImagingStudySeriesComponent", "endpoint", element.getEndpoint().get(i), i);
    }
    if (element.hasBodySite()) {
      composeCodeableReference(t, "ImagingStudySeriesComponent", "bodySite", element.getBodySite(), -1);
    }
    if (element.hasLaterality()) {
      composeCodeableConcept(t, "ImagingStudySeriesComponent", "laterality", element.getLaterality(), -1);
    }
    for (int i = 0; i < element.getSpecimen().size(); i++) {
      composeReference(t, "ImagingStudySeriesComponent", "specimen", element.getSpecimen().get(i), i);
    }
    if (element.hasStartedElement()) {
      composeDateTime(t, "ImagingStudySeriesComponent", "started", element.getStartedElement(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeImagingStudySeriesPerformerComponent(t, "ImagingStudySeriesComponent", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getInstance().size(); i++) {
      composeImagingStudySeriesInstanceComponent(t, "ImagingStudySeriesComponent", "instance", element.getInstance().get(i), i);
    }
  }

  protected void composeImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent 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, "ImagingStudySeriesPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ImagingStudySeriesPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent 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, "instance", name, element, index);
    if (element.hasUidElement()) {
      composeId(t, "ImagingStudySeriesInstanceComponent", "uid", element.getUidElement(), -1);
    }
    if (element.hasSopClass()) {
      composeCoding(t, "ImagingStudySeriesInstanceComponent", "sopClass", element.getSopClass(), -1);
    }
    if (element.hasNumberElement()) {
      composeUnsignedInt(t, "ImagingStudySeriesInstanceComponent", "number", element.getNumberElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ImagingStudySeriesInstanceComponent", "title", element.getTitleElement(), -1);
    }
  }

  protected void composeImmunization(Complex parent, String parentType, String name, Immunization 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, "Immunization", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Immunization", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Immunization", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasVaccineCode()) {
      composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1);
    }
    if (element.hasAdministeredProduct()) {
      composeCodeableReference(t, "Immunization", "administeredProduct", element.getAdministeredProduct(), -1);
    }
    if (element.hasManufacturer()) {
      composeCodeableReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1);
    }
    if (element.hasLotNumberElement()) {
      composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1);
    }
    if (element.hasExpirationDateElement()) {
      composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "Immunization", "patient", element.getPatient(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Immunization", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "Immunization", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    if (element.hasOccurrence()) {
      composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasPrimarySourceElement()) {
      composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1);
    }
    if (element.hasInformationSource()) {
      composeCodeableReference(t, "Immunization", "informationSource", element.getInformationSource(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "Immunization", "location", element.getLocation(), -1);
    }
    if (element.hasSite()) {
      composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1);
    }
    if (element.hasRoute()) {
      composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1);
    }
    if (element.hasDoseQuantity()) {
      composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "Immunization", "reason", element.getReason().get(i), i);
    }
    if (element.hasIsSubpotentElement()) {
      composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1);
    }
    for (int i = 0; i < element.getSubpotentReason().size(); i++) {
      composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i);
    }
    for (int i = 0; i < element.getProgramEligibility().size(); i++) {
      composeImmunizationProgramEligibilityComponent(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i);
    }
    if (element.hasFundingSource()) {
      composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1);
    }
    for (int i = 0; i < element.getReaction().size(); i++) {
      composeImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i);
    }
    for (int i = 0; i < element.getProtocolApplied().size(); i++) {
      composeImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i);
    }
  }

  protected void composeImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent 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, "ImmunizationPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ImmunizationPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeImmunizationProgramEligibilityComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProgramEligibilityComponent 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, "programEligibility", name, element, index);
    if (element.hasProgram()) {
      composeCodeableConcept(t, "ImmunizationProgramEligibilityComponent", "program", element.getProgram(), -1);
    }
    if (element.hasProgramStatus()) {
      composeCodeableConcept(t, "ImmunizationProgramEligibilityComponent", "programStatus", element.getProgramStatus(), -1);
    }
  }

  protected void composeImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent 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.hasDateElement()) {
      composeDateTime(t, "ImmunizationReactionComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasManifestation()) {
      composeCodeableReference(t, "ImmunizationReactionComponent", "manifestation", element.getManifestation(), -1);
    }
    if (element.hasReportedElement()) {
      composeBoolean(t, "ImmunizationReactionComponent", "reported", element.getReportedElement(), -1);
    }
  }

  protected void composeImmunizationProtocolAppliedComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProtocolAppliedComponent 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, "protocolApplied", name, element, index);
    if (element.hasSeriesElement()) {
      composeString(t, "ImmunizationProtocolAppliedComponent", "series", element.getSeriesElement(), -1);
    }
    if (element.hasAuthority()) {
      composeReference(t, "ImmunizationProtocolAppliedComponent", "authority", element.getAuthority(), -1);
    }
    for (int i = 0; i < element.getTargetDisease().size(); i++) {
      composeCodeableConcept(t, "ImmunizationProtocolAppliedComponent", "targetDisease", element.getTargetDisease().get(i), i);
    }
    if (element.hasDoseNumberElement()) {
      composeString(t, "ImmunizationProtocolAppliedComponent", "doseNumber", element.getDoseNumberElement(), -1);
    }
    if (element.hasSeriesDosesElement()) {
      composeString(t, "ImmunizationProtocolAppliedComponent", "seriesDoses", element.getSeriesDosesElement(), -1);
    }
  }

  protected void composeImmunizationEvaluation(Complex parent, String parentType, String name, ImmunizationEvaluation 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, "ImmunizationEvaluation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ImmunizationEvaluation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ImmunizationEvaluation", "status", element.getStatusElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "ImmunizationEvaluation", "patient", element.getPatient(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ImmunizationEvaluation", "date", element.getDateElement(), -1);
    }
    if (element.hasAuthority()) {
      composeReference(t, "ImmunizationEvaluation", "authority", element.getAuthority(), -1);
    }
    if (element.hasTargetDisease()) {
      composeCodeableConcept(t, "ImmunizationEvaluation", "targetDisease", element.getTargetDisease(), -1);
    }
    if (element.hasImmunizationEvent()) {
      composeReference(t, "ImmunizationEvaluation", "immunizationEvent", element.getImmunizationEvent(), -1);
    }
    if (element.hasDoseStatus()) {
      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatus", element.getDoseStatus(), -1);
    }
    for (int i = 0; i < element.getDoseStatusReason().size(); i++) {
      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatusReason", element.getDoseStatusReason().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ImmunizationEvaluation", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasSeriesElement()) {
      composeString(t, "ImmunizationEvaluation", "series", element.getSeriesElement(), -1);
    }
    if (element.hasDoseNumberElement()) {
      composeString(t, "ImmunizationEvaluation", "doseNumber", element.getDoseNumberElement(), -1);
    }
    if (element.hasSeriesDosesElement()) {
      composeString(t, "ImmunizationEvaluation", "seriesDoses", element.getSeriesDosesElement(), -1);
    }
  }

  protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation 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, "ImmunizationRecommendation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1);
    }
    if (element.hasAuthority()) {
      composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1);
    }
    for (int i = 0; i < element.getRecommendation().size(); i++) {
      composeImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i);
    }
  }

  protected void composeImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent 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, "recommendation", name, element, index);
    for (int i = 0; i < element.getVaccineCode().size(); i++) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "vaccineCode", element.getVaccineCode().get(i), i);
    }
    for (int i = 0; i < element.getTargetDisease().size(); i++) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "targetDisease", element.getTargetDisease().get(i), i);
    }
    for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "contraindicatedVaccineCode", element.getContraindicatedVaccineCode().get(i), i);
    }
    if (element.hasForecastStatus()) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastStatus", element.getForecastStatus(), -1);
    }
    for (int i = 0; i < element.getForecastReason().size(); i++) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastReason", element.getForecastReason().get(i), i);
    }
    for (int i = 0; i < element.getDateCriterion().size(); i++) {
      composeImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendationRecommendationComponent", "dateCriterion", element.getDateCriterion().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ImmunizationRecommendationRecommendationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasSeriesElement()) {
      composeString(t, "ImmunizationRecommendationRecommendationComponent", "series", element.getSeriesElement(), -1);
    }
    if (element.hasDoseNumberElement()) {
      composeString(t, "ImmunizationRecommendationRecommendationComponent", "doseNumber", element.getDoseNumberElement(), -1);
    }
    if (element.hasSeriesDosesElement()) {
      composeString(t, "ImmunizationRecommendationRecommendationComponent", "seriesDoses", element.getSeriesDosesElement(), -1);
    }
    for (int i = 0; i < element.getSupportingImmunization().size(); i++) {
      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingImmunization", element.getSupportingImmunization().get(i), i);
    }
    for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) {
      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i);
    }
  }

  protected void composeImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent 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, "dateCriterion", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "code", element.getCode(), -1);
    }
    if (element.hasValueElement()) {
      composeDateTime(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide 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, "ImplementationGuide", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ImplementationGuide", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ImplementationGuide", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ImplementationGuide", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ImplementationGuide", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasPackageIdElement()) {
      composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1);
    }
    if (element.hasLicenseElement()) {
      composeEnum(t, "ImplementationGuide", "license", element.getLicenseElement(), -1);
    }
    for (int i = 0; i < element.getFhirVersion().size(); i++) {
      composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i);
    }
    for (int i = 0; i < element.getDependsOn().size(); i++) {
      composeImplementationGuideDependsOnComponent(t, "ImplementationGuide", "dependsOn", element.getDependsOn().get(i), i);
    }
    for (int i = 0; i < element.getGlobal().size(); i++) {
      composeImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i);
    }
    if (element.hasDefinition()) {
      composeImplementationGuideDefinitionComponent(t, "ImplementationGuide", "definition", element.getDefinition(), -1);
    }
    if (element.hasManifest()) {
      composeImplementationGuideManifestComponent(t, "ImplementationGuide", "manifest", element.getManifest(), -1);
    }
  }

  protected void composeImplementationGuideDependsOnComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependsOnComponent 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.hasUriElement()) {
      composeCanonical(t, "ImplementationGuideDependsOnComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasPackageIdElement()) {
      composeId(t, "ImplementationGuideDependsOnComponent", "packageId", element.getPackageIdElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ImplementationGuideDependsOnComponent", "version", element.getVersionElement(), -1);
    }
    if (element.hasReasonElement()) {
      composeMarkdown(t, "ImplementationGuideDependsOnComponent", "reason", element.getReasonElement(), -1);
    }
  }

  protected void composeImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent 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, "global", name, element, index);
    if (element.hasTypeElement()) {
      composeCode(t, "ImplementationGuideGlobalComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "ImplementationGuideGlobalComponent", "profile", element.getProfileElement(), -1);
    }
  }

  protected void composeImplementationGuideDefinitionComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionComponent 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, "definition", name, element, index);
    for (int i = 0; i < element.getGrouping().size(); i++) {
      composeImplementationGuideDefinitionGroupingComponent(t, "ImplementationGuideDefinitionComponent", "grouping", element.getGrouping().get(i), i);
    }
    for (int i = 0; i < element.getResource().size(); i++) {
      composeImplementationGuideDefinitionResourceComponent(t, "ImplementationGuideDefinitionComponent", "resource", element.getResource().get(i), i);
    }
    if (element.hasPage()) {
      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionComponent", "page", element.getPage(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeImplementationGuideDefinitionParameterComponent(t, "ImplementationGuideDefinitionComponent", "parameter", element.getParameter().get(i), i);
    }
    for (int i = 0; i < element.getTemplate().size(); i++) {
      composeImplementationGuideDefinitionTemplateComponent(t, "ImplementationGuideDefinitionComponent", "template", element.getTemplate().get(i), i);
    }
  }

  protected void composeImplementationGuideDefinitionGroupingComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionGroupingComponent 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, "grouping", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ImplementationGuideDefinitionGroupingComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ImplementationGuideDefinitionGroupingComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeImplementationGuideDefinitionResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionResourceComponent 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.hasReference()) {
      composeReference(t, "ImplementationGuideDefinitionResourceComponent", "reference", element.getReference(), -1);
    }
    for (int i = 0; i < element.getFhirVersion().size(); i++) {
      composeEnum(t, "ImplementationGuideDefinitionResourceComponent", "fhirVersion", element.getFhirVersion().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "ImplementationGuideDefinitionResourceComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ImplementationGuideDefinitionResourceComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasIsExampleElement()) {
      composeBoolean(t, "ImplementationGuideDefinitionResourceComponent", "isExample", element.getIsExampleElement(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "ImplementationGuideDefinitionResourceComponent", "profile", element.getProfile().get(i), i);
    }
    if (element.hasGroupingIdElement()) {
      composeId(t, "ImplementationGuideDefinitionResourceComponent", "groupingId", element.getGroupingIdElement(), -1);
    }
  }

  protected void composeImplementationGuideDefinitionPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionPageComponent 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, "page", name, element, index);
    if (element.hasSource()) {
      composeType(t, "ImplementationGuideDefinitionPageComponent", "source", element.getSource(), -1);
    }
    if (element.hasNameElement()) {
      composeUrl(t, "ImplementationGuideDefinitionPageComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ImplementationGuideDefinitionPageComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasGenerationElement()) {
      composeEnum(t, "ImplementationGuideDefinitionPageComponent", "generation", element.getGenerationElement(), -1);
    }
    for (int i = 0; i < element.getPage().size(); i++) {
      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionPageComponent", "page", element.getPage().get(i), i);
    }
  }

  protected void composeImplementationGuideDefinitionParameterComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionParameterComponent 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, "parameter", name, element, index);
    if (element.hasCode()) {
      composeCoding(t, "ImplementationGuideDefinitionParameterComponent", "code", element.getCode(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "ImplementationGuideDefinitionParameterComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeImplementationGuideDefinitionTemplateComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionTemplateComponent 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, "template", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "ImplementationGuideDefinitionTemplateComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasSourceElement()) {
      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "source", element.getSourceElement(), -1);
    }
    if (element.hasScopeElement()) {
      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "scope", element.getScopeElement(), -1);
    }
  }

  protected void composeImplementationGuideManifestComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideManifestComponent 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, "manifest", name, element, index);
    if (element.hasRenderingElement()) {
      composeUrl(t, "ImplementationGuideManifestComponent", "rendering", element.getRenderingElement(), -1);
    }
    for (int i = 0; i < element.getResource().size(); i++) {
      composeImplementationGuideManifestResourceComponent(t, "ImplementationGuideManifestComponent", "resource", element.getResource().get(i), i);
    }
    for (int i = 0; i < element.getPage().size(); i++) {
      composeImplementationGuideManifestPageComponent(t, "ImplementationGuideManifestComponent", "page", element.getPage().get(i), i);
    }
    for (int i = 0; i < element.getImage().size(); i++) {
      composeString(t, "ImplementationGuideManifestComponent", "image", element.getImage().get(i), i);
    }
    for (int i = 0; i < element.getOther().size(); i++) {
      composeString(t, "ImplementationGuideManifestComponent", "other", element.getOther().get(i), i);
    }
  }

  protected void composeImplementationGuideManifestResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestResourceComponent 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.hasReference()) {
      composeReference(t, "ManifestResourceComponent", "reference", element.getReference(), -1);
    }
    if (element.hasIsExampleElement()) {
      composeBoolean(t, "ManifestResourceComponent", "isExample", element.getIsExampleElement(), -1);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "ManifestResourceComponent", "profile", element.getProfile().get(i), i);
    }
    if (element.hasRelativePathElement()) {
      composeUrl(t, "ManifestResourceComponent", "relativePath", element.getRelativePathElement(), -1);
    }
  }

  protected void composeImplementationGuideManifestPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestPageComponent 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, "page", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ManifestPageComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ManifestPageComponent", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getAnchor().size(); i++) {
      composeString(t, "ManifestPageComponent", "anchor", element.getAnchor().get(i), i);
    }
  }

  protected void composeIngredient(Complex parent, String parentType, String name, Ingredient 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, "Ingredient", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "Ingredient", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Ingredient", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getFor().size(); i++) {
      composeReference(t, "Ingredient", "for", element.getFor().get(i), i);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "Ingredient", "role", element.getRole(), -1);
    }
    for (int i = 0; i < element.getFunction().size(); i++) {
      composeCodeableConcept(t, "Ingredient", "function", element.getFunction().get(i), i);
    }
    if (element.hasGroup()) {
      composeCodeableConcept(t, "Ingredient", "group", element.getGroup(), -1);
    }
    if (element.hasAllergenicIndicatorElement()) {
      composeBoolean(t, "Ingredient", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "Ingredient", "comment", element.getCommentElement(), -1);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeIngredientManufacturerComponent(t, "Ingredient", "manufacturer", element.getManufacturer().get(i), i);
    }
    if (element.hasSubstance()) {
      composeIngredientSubstanceComponent(t, "Ingredient", "substance", element.getSubstance(), -1);
    }
  }

  protected void composeIngredientManufacturerComponent(Complex parent, String parentType, String name, Ingredient.IngredientManufacturerComponent 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, "manufacturer", name, element, index);
    if (element.hasRoleElement()) {
      composeEnum(t, "IngredientManufacturerComponent", "role", element.getRoleElement(), -1);
    }
    if (element.hasManufacturer()) {
      composeReference(t, "IngredientManufacturerComponent", "manufacturer", element.getManufacturer(), -1);
    }
  }

  protected void composeIngredientSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceComponent 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, "substance", name, element, index);
    if (element.hasCode()) {
      composeCodeableReference(t, "IngredientSubstanceComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getStrength().size(); i++) {
      composeIngredientSubstanceStrengthComponent(t, "IngredientSubstanceComponent", "strength", element.getStrength().get(i), i);
    }
  }

  protected void composeIngredientSubstanceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceStrengthComponent 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, "strength", name, element, index);
    if (element.hasPresentation()) {
      composeType(t, "IngredientSubstanceStrengthComponent", "presentation", element.getPresentation(), -1);
    }
    if (element.hasTextPresentationElement()) {
      composeString(t, "IngredientSubstanceStrengthComponent", "textPresentation", element.getTextPresentationElement(), -1);
    }
    if (element.hasConcentration()) {
      composeType(t, "IngredientSubstanceStrengthComponent", "concentration", element.getConcentration(), -1);
    }
    if (element.hasTextConcentrationElement()) {
      composeString(t, "IngredientSubstanceStrengthComponent", "textConcentration", element.getTextConcentrationElement(), -1);
    }
    if (element.hasBasis()) {
      composeCodeableConcept(t, "IngredientSubstanceStrengthComponent", "basis", element.getBasis(), -1);
    }
    if (element.hasMeasurementPointElement()) {
      composeString(t, "IngredientSubstanceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
    }
    for (int i = 0; i < element.getCountry().size(); i++) {
      composeCodeableConcept(t, "IngredientSubstanceStrengthComponent", "country", element.getCountry().get(i), i);
    }
    for (int i = 0; i < element.getReferenceStrength().size(); i++) {
      composeIngredientSubstanceStrengthReferenceStrengthComponent(t, "IngredientSubstanceStrengthComponent", "referenceStrength", element.getReferenceStrength().get(i), i);
    }
  }

  protected void composeIngredientSubstanceStrengthReferenceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceStrengthReferenceStrengthComponent 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, "referenceStrength", name, element, index);
    if (element.hasSubstance()) {
      composeCodeableReference(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "substance", element.getSubstance(), -1);
    }
    if (element.hasStrength()) {
      composeType(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "strength", element.getStrength(), -1);
    }
    if (element.hasMeasurementPointElement()) {
      composeString(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
    }
    for (int i = 0; i < element.getCountry().size(); i++) {
      composeCodeableConcept(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "country", element.getCountry().get(i), i);
    }
  }

  protected void composeInsurancePlan(Complex parent, String parentType, String name, InsurancePlan 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, "InsurancePlan", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "InsurancePlan", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "InsurancePlan", "type", element.getType().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "InsurancePlan", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getAlias().size(); i++) {
      composeString(t, "InsurancePlan", "alias", element.getAlias().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "InsurancePlan", "period", element.getPeriod(), -1);
    }
    if (element.hasOwnedBy()) {
      composeReference(t, "InsurancePlan", "ownedBy", element.getOwnedBy(), -1);
    }
    if (element.hasAdministeredBy()) {
      composeReference(t, "InsurancePlan", "administeredBy", element.getAdministeredBy(), -1);
    }
    for (int i = 0; i < element.getCoverageArea().size(); i++) {
      composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "InsurancePlan", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "InsurancePlan", "endpoint", element.getEndpoint().get(i), i);
    }
    for (int i = 0; i < element.getNetwork().size(); i++) {
      composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i);
    }
    for (int i = 0; i < element.getCoverage().size(); i++) {
      composeInsurancePlanCoverageComponent(t, "InsurancePlan", "coverage", element.getCoverage().get(i), i);
    }
    for (int i = 0; i < element.getPlan().size(); i++) {
      composeInsurancePlanPlanComponent(t, "InsurancePlan", "plan", element.getPlan().get(i), i);
    }
  }

  protected void composeInsurancePlanCoverageComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanCoverageComponent 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.hasType()) {
      composeCodeableConcept(t, "InsurancePlanCoverageComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getNetwork().size(); i++) {
      composeReference(t, "InsurancePlanCoverageComponent", "network", element.getNetwork().get(i), i);
    }
    for (int i = 0; i < element.getBenefit().size(); i++) {
      composeInsurancePlanCoverageBenefitComponent(t, "InsurancePlanCoverageComponent", "benefit", element.getBenefit().get(i), i);
    }
  }

  protected void composeInsurancePlanCoverageBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitComponent 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, "benefit", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "CoverageBenefitComponent", "type", element.getType(), -1);
    }
    if (element.hasRequirementElement()) {
      composeString(t, "CoverageBenefitComponent", "requirement", element.getRequirementElement(), -1);
    }
    for (int i = 0; i < element.getLimit().size(); i++) {
      composeInsurancePlanCoverageBenefitLimitComponent(t, "CoverageBenefitComponent", "limit", element.getLimit().get(i), i);
    }
  }

  protected void composeInsurancePlanCoverageBenefitLimitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitLimitComponent 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, "limit", name, element, index);
    if (element.hasValue()) {
      composeQuantity(t, "CoverageBenefitLimitComponent", "value", element.getValue(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "CoverageBenefitLimitComponent", "code", element.getCode(), -1);
    }
  }

  protected void composeInsurancePlanPlanComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanComponent 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);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "InsurancePlanPlanComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "InsurancePlanPlanComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getCoverageArea().size(); i++) {
      composeReference(t, "InsurancePlanPlanComponent", "coverageArea", element.getCoverageArea().get(i), i);
    }
    for (int i = 0; i < element.getNetwork().size(); i++) {
      composeReference(t, "InsurancePlanPlanComponent", "network", element.getNetwork().get(i), i);
    }
    for (int i = 0; i < element.getGeneralCost().size(); i++) {
      composeInsurancePlanPlanGeneralCostComponent(t, "InsurancePlanPlanComponent", "generalCost", element.getGeneralCost().get(i), i);
    }
    for (int i = 0; i < element.getSpecificCost().size(); i++) {
      composeInsurancePlanPlanSpecificCostComponent(t, "InsurancePlanPlanComponent", "specificCost", element.getSpecificCost().get(i), i);
    }
  }

  protected void composeInsurancePlanPlanGeneralCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanGeneralCostComponent 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, "generalCost", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "InsurancePlanPlanGeneralCostComponent", "type", element.getType(), -1);
    }
    if (element.hasGroupSizeElement()) {
      composePositiveInt(t, "InsurancePlanPlanGeneralCostComponent", "groupSize", element.getGroupSizeElement(), -1);
    }
    if (element.hasCost()) {
      composeMoney(t, "InsurancePlanPlanGeneralCostComponent", "cost", element.getCost(), -1);
    }
    if (element.hasCommentElement()) {
      composeString(t, "InsurancePlanPlanGeneralCostComponent", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeInsurancePlanPlanSpecificCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanSpecificCostComponent 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, "specificCost", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "InsurancePlanPlanSpecificCostComponent", "category", element.getCategory(), -1);
    }
    for (int i = 0; i < element.getBenefit().size(); i++) {
      composeInsurancePlanPlanBenefitComponent(t, "InsurancePlanPlanSpecificCostComponent", "benefit", element.getBenefit().get(i), i);
    }
  }

  protected void composeInsurancePlanPlanBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitComponent 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, "benefit", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "PlanBenefitComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getCost().size(); i++) {
      composeInsurancePlanPlanBenefitCostComponent(t, "PlanBenefitComponent", "cost", element.getCost().get(i), i);
    }
  }

  protected void composeInsurancePlanPlanBenefitCostComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitCostComponent 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, "cost", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "PlanBenefitCostComponent", "type", element.getType(), -1);
    }
    if (element.hasApplicability()) {
      composeCodeableConcept(t, "PlanBenefitCostComponent", "applicability", element.getApplicability(), -1);
    }
    for (int i = 0; i < element.getQualifiers().size(); i++) {
      composeCodeableConcept(t, "PlanBenefitCostComponent", "qualifiers", element.getQualifiers().get(i), i);
    }
    if (element.hasValue()) {
      composeQuantity(t, "PlanBenefitCostComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeInventoryItem(Complex parent, String parentType, String name, InventoryItem 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, "InventoryItem", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "InventoryItem", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "InventoryItem", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "InventoryItem", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "InventoryItem", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeInventoryItemNameComponent(t, "InventoryItem", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getResponsibleOrganization().size(); i++) {
      composeInventoryItemResponsibleOrganizationComponent(t, "InventoryItem", "responsibleOrganization", element.getResponsibleOrganization().get(i), i);
    }
    if (element.hasDescription()) {
      composeInventoryItemDescriptionComponent(t, "InventoryItem", "description", element.getDescription(), -1);
    }
    for (int i = 0; i < element.getInventoryStatus().size(); i++) {
      composeCodeableConcept(t, "InventoryItem", "inventoryStatus", element.getInventoryStatus().get(i), i);
    }
    if (element.hasBaseUnit()) {
      composeCodeableConcept(t, "InventoryItem", "baseUnit", element.getBaseUnit(), -1);
    }
    if (element.hasNetContent()) {
      composeQuantity(t, "InventoryItem", "netContent", element.getNetContent(), -1);
    }
    for (int i = 0; i < element.getAssociation().size(); i++) {
      composeInventoryItemAssociationComponent(t, "InventoryItem", "association", element.getAssociation().get(i), i);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeInventoryItemCharacteristicComponent(t, "InventoryItem", "characteristic", element.getCharacteristic().get(i), i);
    }
    if (element.hasInstance()) {
      composeInventoryItemInstanceComponent(t, "InventoryItem", "instance", element.getInstance(), -1);
    }
    if (element.hasProductReference()) {
      composeReference(t, "InventoryItem", "productReference", element.getProductReference(), -1);
    }
  }

  protected void composeInventoryItemNameComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemNameComponent 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, "name", name, element, index);
    if (element.hasNameType()) {
      composeCoding(t, "InventoryItemNameComponent", "nameType", element.getNameType(), -1);
    }
    if (element.hasLanguageElement()) {
      composeEnum(t, "InventoryItemNameComponent", "language", element.getLanguageElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "InventoryItemNameComponent", "name", element.getNameElement(), -1);
    }
  }

  protected void composeInventoryItemResponsibleOrganizationComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemResponsibleOrganizationComponent 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, "responsibleOrganization", name, element, index);
    if (element.hasRole()) {
      composeCodeableConcept(t, "InventoryItemResponsibleOrganizationComponent", "role", element.getRole(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "InventoryItemResponsibleOrganizationComponent", "organization", element.getOrganization(), -1);
    }
  }

  protected void composeInventoryItemDescriptionComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemDescriptionComponent 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, "description", name, element, index);
    if (element.hasLanguageElement()) {
      composeEnum(t, "InventoryItemDescriptionComponent", "language", element.getLanguageElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "InventoryItemDescriptionComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeInventoryItemAssociationComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemAssociationComponent 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, "association", name, element, index);
    if (element.hasAssociationType()) {
      composeCodeableConcept(t, "InventoryItemAssociationComponent", "associationType", element.getAssociationType(), -1);
    }
    if (element.hasRelatedItem()) {
      composeReference(t, "InventoryItemAssociationComponent", "relatedItem", element.getRelatedItem(), -1);
    }
    if (element.hasQuantity()) {
      composeRatio(t, "InventoryItemAssociationComponent", "quantity", element.getQuantity(), -1);
    }
  }

  protected void composeInventoryItemCharacteristicComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasCharacteristicType()) {
      composeCodeableConcept(t, "InventoryItemCharacteristicComponent", "characteristicType", element.getCharacteristicType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "InventoryItemCharacteristicComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeInventoryItemInstanceComponent(Complex parent, String parentType, String name, InventoryItem.InventoryItemInstanceComponent 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, "instance", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "InventoryItemInstanceComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasLotNumberElement()) {
      composeString(t, "InventoryItemInstanceComponent", "lotNumber", element.getLotNumberElement(), -1);
    }
    if (element.hasExpiryElement()) {
      composeDateTime(t, "InventoryItemInstanceComponent", "expiry", element.getExpiryElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "InventoryItemInstanceComponent", "subject", element.getSubject(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "InventoryItemInstanceComponent", "location", element.getLocation(), -1);
    }
  }

  protected void composeInventoryReport(Complex parent, String parentType, String name, InventoryReport 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, "InventoryReport", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "InventoryReport", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "InventoryReport", "status", element.getStatusElement(), -1);
    }
    if (element.hasCountTypeElement()) {
      composeEnum(t, "InventoryReport", "countType", element.getCountTypeElement(), -1);
    }
    if (element.hasOperationType()) {
      composeCodeableConcept(t, "InventoryReport", "operationType", element.getOperationType(), -1);
    }
    if (element.hasOperationTypeReason()) {
      composeCodeableConcept(t, "InventoryReport", "operationTypeReason", element.getOperationTypeReason(), -1);
    }
    if (element.hasReportedDateTimeElement()) {
      composeDateTime(t, "InventoryReport", "reportedDateTime", element.getReportedDateTimeElement(), -1);
    }
    if (element.hasReporter()) {
      composeReference(t, "InventoryReport", "reporter", element.getReporter(), -1);
    }
    if (element.hasReportingPeriod()) {
      composePeriod(t, "InventoryReport", "reportingPeriod", element.getReportingPeriod(), -1);
    }
    for (int i = 0; i < element.getInventoryListing().size(); i++) {
      composeInventoryReportInventoryListingComponent(t, "InventoryReport", "inventoryListing", element.getInventoryListing().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "InventoryReport", "note", element.getNote().get(i), i);
    }
  }

  protected void composeInventoryReportInventoryListingComponent(Complex parent, String parentType, String name, InventoryReport.InventoryReportInventoryListingComponent 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, "inventoryListing", name, element, index);
    if (element.hasLocation()) {
      composeReference(t, "InventoryReportInventoryListingComponent", "location", element.getLocation(), -1);
    }
    if (element.hasItemStatus()) {
      composeCodeableConcept(t, "InventoryReportInventoryListingComponent", "itemStatus", element.getItemStatus(), -1);
    }
    if (element.hasCountingDateTimeElement()) {
      composeDateTime(t, "InventoryReportInventoryListingComponent", "countingDateTime", element.getCountingDateTimeElement(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeInventoryReportInventoryListingItemComponent(t, "InventoryReportInventoryListingComponent", "item", element.getItem().get(i), i);
    }
  }

  protected void composeInventoryReportInventoryListingItemComponent(Complex parent, String parentType, String name, InventoryReport.InventoryReportInventoryListingItemComponent 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, "InventoryReportInventoryListingItemComponent", "category", element.getCategory(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "InventoryReportInventoryListingItemComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasItem()) {
      composeCodeableReference(t, "InventoryReportInventoryListingItemComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeInvoice(Complex parent, String parentType, String name, Invoice 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, "Invoice", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Invoice", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Invoice", "status", element.getStatusElement(), -1);
    }
    if (element.hasCancelledReasonElement()) {
      composeString(t, "Invoice", "cancelledReason", element.getCancelledReasonElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Invoice", "type", element.getType(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Invoice", "subject", element.getSubject(), -1);
    }
    if (element.hasRecipient()) {
      composeReference(t, "Invoice", "recipient", element.getRecipient(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Invoice", "date", element.getDateElement(), -1);
    }
    if (element.hasCreationElement()) {
      composeDateTime(t, "Invoice", "creation", element.getCreationElement(), -1);
    }
    if (element.hasPeriod()) {
      composeType(t, "Invoice", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeInvoiceParticipantComponent(t, "Invoice", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasIssuer()) {
      composeReference(t, "Invoice", "issuer", element.getIssuer(), -1);
    }
    if (element.hasAccount()) {
      composeReference(t, "Invoice", "account", element.getAccount(), -1);
    }
    for (int i = 0; i < element.getLineItem().size(); i++) {
      composeInvoiceLineItemComponent(t, "Invoice", "lineItem", element.getLineItem().get(i), i);
    }
    for (int i = 0; i < element.getTotalPriceComponent().size(); i++) {
      composeMonetaryComponent(t, "Invoice", "totalPriceComponent", element.getTotalPriceComponent().get(i), i);
    }
    if (element.hasTotalNet()) {
      composeMoney(t, "Invoice", "totalNet", element.getTotalNet(), -1);
    }
    if (element.hasTotalGross()) {
      composeMoney(t, "Invoice", "totalGross", element.getTotalGross(), -1);
    }
    if (element.hasPaymentTermsElement()) {
      composeMarkdown(t, "Invoice", "paymentTerms", element.getPaymentTermsElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Invoice", "note", element.getNote().get(i), i);
    }
  }

  protected void composeInvoiceParticipantComponent(Complex parent, String parentType, String name, Invoice.InvoiceParticipantComponent 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, "InvoiceParticipantComponent", "role", element.getRole(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "InvoiceParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeInvoiceLineItemComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemComponent 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, "lineItem", name, element, index);
    if (element.hasSequenceElement()) {
      composePositiveInt(t, "InvoiceLineItemComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasServiced()) {
      composeType(t, "InvoiceLineItemComponent", "serviced", element.getServiced(), -1);
    }
    if (element.hasChargeItem()) {
      composeType(t, "InvoiceLineItemComponent", "chargeItem", element.getChargeItem(), -1);
    }
    for (int i = 0; i < element.getPriceComponent().size(); i++) {
      composeMonetaryComponent(t, "InvoiceLineItemComponent", "priceComponent", element.getPriceComponent().get(i), i);
    }
  }

  protected void composeLibrary(Complex parent, String parentType, String name, Library 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, "Library", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Library", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Library", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Library", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Library", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Library", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "Library", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Library", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Library", "type", element.getType(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "Library", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Library", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Library", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Library", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasUsageElement()) {
      composeMarkdown(t, "Library", "usage", element.getUsageElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Library", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "Library", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "Library", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "Library", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "Library", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i);
    }
    for (int i = 0; i < element.getDataRequirement().size(); i++) {
      composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i);
    }
    for (int i = 0; i < element.getContent().size(); i++) {
      composeAttachment(t, "Library", "content", element.getContent().get(i), i);
    }
  }

  protected void composeLinkage(Complex parent, String parentType, String name, Linkage 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, "Linkage", name, element, index);
    if (element.hasActiveElement()) {
      composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "Linkage", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i);
    }
  }

  protected void composeLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent 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.hasTypeElement()) {
      composeEnum(t, "LinkageItemComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasResource()) {
      composeReference(t, "LinkageItemComponent", "resource", element.getResource(), -1);
    }
  }

  protected void composeListResource(Complex parent, String parentType, String name, ListResource 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, "List", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ListResource", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ListResource", "status", element.getStatusElement(), -1);
    }
    if (element.hasModeElement()) {
      composeEnum(t, "ListResource", "mode", element.getModeElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ListResource", "title", element.getTitleElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ListResource", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "ListResource", "subject", element.getSubject().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "ListResource", "encounter", element.getEncounter(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ListResource", "date", element.getDateElement(), -1);
    }
    if (element.hasSource()) {
      composeReference(t, "ListResource", "source", element.getSource(), -1);
    }
    if (element.hasOrderedBy()) {
      composeCodeableConcept(t, "ListResource", "orderedBy", element.getOrderedBy(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ListResource", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getEntry().size(); i++) {
      composeListResourceEntryComponent(t, "ListResource", "entry", element.getEntry().get(i), i);
    }
    if (element.hasEmptyReason()) {
      composeCodeableConcept(t, "ListResource", "emptyReason", element.getEmptyReason(), -1);
    }
  }

  protected void composeListResourceEntryComponent(Complex parent, String parentType, String name, ListResource.ListResourceEntryComponent 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.hasFlag()) {
      composeCodeableConcept(t, "ListResourceEntryComponent", "flag", element.getFlag(), -1);
    }
    if (element.hasDeletedElement()) {
      composeBoolean(t, "ListResourceEntryComponent", "deleted", element.getDeletedElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ListResourceEntryComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasItem()) {
      composeReference(t, "ListResourceEntryComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeLocation(Complex parent, String parentType, String name, Location 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, "Location", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Location", "status", element.getStatusElement(), -1);
    }
    if (element.hasOperationalStatus()) {
      composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Location", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getAlias().size(); i++) {
      composeString(t, "Location", "alias", element.getAlias().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Location", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasModeElement()) {
      composeEnum(t, "Location", "mode", element.getModeElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "Location", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "Location", "contact", element.getContact().get(i), i);
    }
    if (element.hasAddress()) {
      composeAddress(t, "Location", "address", element.getAddress(), -1);
    }
    if (element.hasForm()) {
      composeCodeableConcept(t, "Location", "form", element.getForm(), -1);
    }
    if (element.hasPosition()) {
      composeLocationPositionComponent(t, "Location", "position", element.getPosition(), -1);
    }
    if (element.hasManagingOrganization()) {
      composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1);
    }
    if (element.hasPartOf()) {
      composeReference(t, "Location", "partOf", element.getPartOf(), -1);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeCodeableConcept(t, "Location", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getHoursOfOperation().size(); i++) {
      composeAvailability(t, "Location", "hoursOfOperation", element.getHoursOfOperation().get(i), i);
    }
    for (int i = 0; i < element.getVirtualService().size(); i++) {
      composeVirtualServiceDetail(t, "Location", "virtualService", element.getVirtualService().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i);
    }
  }

  protected void composeLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent 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, "position", name, element, index);
    if (element.hasLongitudeElement()) {
      composeDecimal(t, "LocationPositionComponent", "longitude", element.getLongitudeElement(), -1);
    }
    if (element.hasLatitudeElement()) {
      composeDecimal(t, "LocationPositionComponent", "latitude", element.getLatitudeElement(), -1);
    }
    if (element.hasAltitudeElement()) {
      composeDecimal(t, "LocationPositionComponent", "altitude", element.getAltitudeElement(), -1);
    }
  }

  protected void composeManufacturedItemDefinition(Complex parent, String parentType, String name, ManufacturedItemDefinition 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, "ManufacturedItemDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ManufacturedItemDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ManufacturedItemDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ManufacturedItemDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasManufacturedDoseForm()) {
      composeCodeableConcept(t, "ManufacturedItemDefinition", "manufacturedDoseForm", element.getManufacturedDoseForm(), -1);
    }
    if (element.hasUnitOfPresentation()) {
      composeCodeableConcept(t, "ManufacturedItemDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeReference(t, "ManufacturedItemDefinition", "manufacturer", element.getManufacturer().get(i), i);
    }
    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
      composeMarketingStatus(t, "ManufacturedItemDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeCodeableConcept(t, "ManufacturedItemDefinition", "ingredient", element.getIngredient().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeManufacturedItemDefinitionPropertyComponent(t, "ManufacturedItemDefinition", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeManufacturedItemDefinitionComponentComponent(t, "ManufacturedItemDefinition", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeManufacturedItemDefinitionPropertyComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionPropertyComponent 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, "ManufacturedItemDefinitionPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ManufacturedItemDefinitionPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeManufacturedItemDefinitionComponentComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionComponentComponent 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, "component", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ManufacturedItemDefinitionComponentComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getFunction().size(); i++) {
      composeCodeableConcept(t, "ManufacturedItemDefinitionComponentComponent", "function", element.getFunction().get(i), i);
    }
    for (int i = 0; i < element.getAmount().size(); i++) {
      composeQuantity(t, "ManufacturedItemDefinitionComponentComponent", "amount", element.getAmount().get(i), i);
    }
    for (int i = 0; i < element.getConstituent().size(); i++) {
      composeManufacturedItemDefinitionComponentConstituentComponent(t, "ManufacturedItemDefinitionComponentComponent", "constituent", element.getConstituent().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeManufacturedItemDefinitionPropertyComponent(t, "ManufacturedItemDefinitionComponentComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeManufacturedItemDefinitionComponentComponent(t, "ManufacturedItemDefinitionComponentComponent", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeManufacturedItemDefinitionComponentConstituentComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionComponentConstituentComponent 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, "constituent", name, element, index);
    for (int i = 0; i < element.getAmount().size(); i++) {
      composeQuantity(t, "ManufacturedItemDefinitionComponentConstituentComponent", "amount", element.getAmount().get(i), i);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeCodeableConcept(t, "ManufacturedItemDefinitionComponentConstituentComponent", "location", element.getLocation().get(i), i);
    }
    for (int i = 0; i < element.getFunction().size(); i++) {
      composeCodeableConcept(t, "ManufacturedItemDefinitionComponentConstituentComponent", "function", element.getFunction().get(i), i);
    }
    for (int i = 0; i < element.getHasIngredient().size(); i++) {
      composeCodeableReference(t, "ManufacturedItemDefinitionComponentConstituentComponent", "hasIngredient", element.getHasIngredient().get(i), i);
    }
  }

  protected void composeMeasure(Complex parent, String parentType, String name, Measure 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, "Measure", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Measure", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Measure", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Measure", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Measure", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Measure", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "Measure", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Measure", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "Measure", "subject", element.getSubject(), -1);
    }
    if (element.hasBasisElement()) {
      composeEnum(t, "Measure", "basis", element.getBasisElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Measure", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Measure", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasUsageElement()) {
      composeMarkdown(t, "Measure", "usage", element.getUsageElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Measure", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "Measure", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "Measure", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "Measure", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "Measure", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getLibrary().size(); i++) {
      composeCanonical(t, "Measure", "library", element.getLibrary().get(i), i);
    }
    if (element.hasDisclaimerElement()) {
      composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1);
    }
    if (element.hasScoring()) {
      composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1);
    }
    if (element.hasScoringUnit()) {
      composeCodeableConcept(t, "Measure", "scoringUnit", element.getScoringUnit(), -1);
    }
    if (element.hasCompositeScoring()) {
      composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i);
    }
    if (element.hasRiskAdjustmentElement()) {
      composeMarkdown(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1);
    }
    if (element.hasRateAggregationElement()) {
      composeMarkdown(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1);
    }
    if (element.hasRationaleElement()) {
      composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1);
    }
    if (element.hasClinicalRecommendationStatementElement()) {
      composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1);
    }
    if (element.hasImprovementNotation()) {
      composeCodeableConcept(t, "Measure", "improvementNotation", element.getImprovementNotation(), -1);
    }
    for (int i = 0; i < element.getTerm().size(); i++) {
      composeMeasureTermComponent(t, "Measure", "term", element.getTerm().get(i), i);
    }
    if (element.hasGuidanceElement()) {
      composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1);
    }
    for (int i = 0; i < element.getGroup().size(); i++) {
      composeMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i);
    }
    for (int i = 0; i < element.getSupplementalData().size(); i++) {
      composeMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i);
    }
  }

  protected void composeMeasureTermComponent(Complex parent, String parentType, String name, Measure.MeasureTermComponent 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.hasCode()) {
      composeCodeableConcept(t, "MeasureTermComponent", "code", element.getCode(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeMarkdown(t, "MeasureTermComponent", "definition", element.getDefinitionElement(), -1);
    }
  }

  protected void composeMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent 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.hasLinkIdElement()) {
      composeString(t, "MeasureGroupComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureGroupComponent", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MeasureGroupComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "MeasureGroupComponent", "type", element.getType().get(i), i);
    }
    if (element.hasSubject()) {
      composeType(t, "MeasureGroupComponent", "subject", element.getSubject(), -1);
    }
    if (element.hasBasisElement()) {
      composeEnum(t, "MeasureGroupComponent", "basis", element.getBasisElement(), -1);
    }
    if (element.hasScoring()) {
      composeCodeableConcept(t, "MeasureGroupComponent", "scoring", element.getScoring(), -1);
    }
    if (element.hasScoringUnit()) {
      composeCodeableConcept(t, "MeasureGroupComponent", "scoringUnit", element.getScoringUnit(), -1);
    }
    if (element.hasRateAggregationElement()) {
      composeMarkdown(t, "MeasureGroupComponent", "rateAggregation", element.getRateAggregationElement(), -1);
    }
    if (element.hasImprovementNotation()) {
      composeCodeableConcept(t, "MeasureGroupComponent", "improvementNotation", element.getImprovementNotation(), -1);
    }
    for (int i = 0; i < element.getLibrary().size(); i++) {
      composeCanonical(t, "MeasureGroupComponent", "library", element.getLibrary().get(i), i);
    }
    for (int i = 0; i < element.getPopulation().size(); i++) {
      composeMeasureGroupPopulationComponent(t, "MeasureGroupComponent", "population", element.getPopulation().get(i), i);
    }
    for (int i = 0; i < element.getStratifier().size(); i++) {
      composeMeasureGroupStratifierComponent(t, "MeasureGroupComponent", "stratifier", element.getStratifier().get(i), i);
    }
  }

  protected void composeMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent 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, "population", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureGroupPopulationComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureGroupPopulationComponent", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MeasureGroupPopulationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCriteria()) {
      composeExpression(t, "MeasureGroupPopulationComponent", "criteria", element.getCriteria(), -1);
    }
    if (element.hasGroupDefinition()) {
      composeReference(t, "MeasureGroupPopulationComponent", "groupDefinition", element.getGroupDefinition(), -1);
    }
    if (element.hasInputPopulationIdElement()) {
      composeString(t, "MeasureGroupPopulationComponent", "inputPopulationId", element.getInputPopulationIdElement(), -1);
    }
    if (element.hasAggregateMethod()) {
      composeCodeableConcept(t, "MeasureGroupPopulationComponent", "aggregateMethod", element.getAggregateMethod(), -1);
    }
  }

  protected void composeMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent 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, "stratifier", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureGroupStratifierComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureGroupStratifierComponent", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MeasureGroupStratifierComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCriteria()) {
      composeExpression(t, "MeasureGroupStratifierComponent", "criteria", element.getCriteria(), -1);
    }
    if (element.hasGroupDefinition()) {
      composeReference(t, "MeasureGroupStratifierComponent", "groupDefinition", element.getGroupDefinition(), -1);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeMeasureGroupStratifierComponentComponent(t, "MeasureGroupStratifierComponent", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeMeasureGroupStratifierComponentComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponentComponent 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, "component", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureGroupStratifierComponentComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureGroupStratifierComponentComponent", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MeasureGroupStratifierComponentComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCriteria()) {
      composeExpression(t, "MeasureGroupStratifierComponentComponent", "criteria", element.getCriteria(), -1);
    }
    if (element.hasGroupDefinition()) {
      composeReference(t, "MeasureGroupStratifierComponentComponent", "groupDefinition", element.getGroupDefinition(), -1);
    }
  }

  protected void composeMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent 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, "supplementalData", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureSupplementalDataComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getUsage().size(); i++) {
      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "usage", element.getUsage().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MeasureSupplementalDataComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCriteria()) {
      composeExpression(t, "MeasureSupplementalDataComponent", "criteria", element.getCriteria(), -1);
    }
  }

  protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport 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, "MeasureReport", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1);
    }
    if (element.hasDataUpdateTypeElement()) {
      composeEnum(t, "MeasureReport", "dataUpdateType", element.getDataUpdateTypeElement(), -1);
    }
    if (element.hasMeasureElement()) {
      composeCanonical(t, "MeasureReport", "measure", element.getMeasureElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MeasureReport", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1);
    }
    if (element.hasReporter()) {
      composeReference(t, "MeasureReport", "reporter", element.getReporter(), -1);
    }
    if (element.hasReportingVendor()) {
      composeReference(t, "MeasureReport", "reportingVendor", element.getReportingVendor(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "MeasureReport", "location", element.getLocation(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1);
    }
    if (element.hasInputParameters()) {
      composeReference(t, "MeasureReport", "inputParameters", element.getInputParameters(), -1);
    }
    if (element.hasScoring()) {
      composeCodeableConcept(t, "MeasureReport", "scoring", element.getScoring(), -1);
    }
    if (element.hasImprovementNotation()) {
      composeCodeableConcept(t, "MeasureReport", "improvementNotation", element.getImprovementNotation(), -1);
    }
    for (int i = 0; i < element.getGroup().size(); i++) {
      composeMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i);
    }
    for (int i = 0; i < element.getSupplementalData().size(); i++) {
      composeReference(t, "MeasureReport", "supplementalData", element.getSupplementalData().get(i), i);
    }
    for (int i = 0; i < element.getEvaluatedResource().size(); i++) {
      composeReference(t, "MeasureReport", "evaluatedResource", element.getEvaluatedResource().get(i), i);
    }
  }

  protected void composeMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent 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.hasLinkIdElement()) {
      composeString(t, "MeasureReportGroupComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureReportGroupComponent", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MeasureReportGroupComponent", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getPopulation().size(); i++) {
      composeMeasureReportGroupPopulationComponent(t, "MeasureReportGroupComponent", "population", element.getPopulation().get(i), i);
    }
    if (element.hasMeasureScore()) {
      composeType(t, "MeasureReportGroupComponent", "measureScore", element.getMeasureScore(), -1);
    }
    for (int i = 0; i < element.getStratifier().size(); i++) {
      composeMeasureReportGroupStratifierComponent(t, "MeasureReportGroupComponent", "stratifier", element.getStratifier().get(i), i);
    }
  }

  protected void composeMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent 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, "population", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureReportGroupPopulationComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureReportGroupPopulationComponent", "code", element.getCode(), -1);
    }
    if (element.hasCountElement()) {
      composeInteger(t, "MeasureReportGroupPopulationComponent", "count", element.getCountElement(), -1);
    }
    if (element.hasSubjectResults()) {
      composeReference(t, "MeasureReportGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
    }
    for (int i = 0; i < element.getSubjectReport().size(); i++) {
      composeReference(t, "MeasureReportGroupPopulationComponent", "subjectReport", element.getSubjectReport().get(i), i);
    }
    if (element.hasSubjects()) {
      composeReference(t, "MeasureReportGroupPopulationComponent", "subjects", element.getSubjects(), -1);
    }
  }

  protected void composeMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent 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, "stratifier", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "MeasureReportGroupStratifierComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MeasureReportGroupStratifierComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getStratum().size(); i++) {
      composeMeasureReportStratifierGroupComponent(t, "MeasureReportGroupStratifierComponent", "stratum", element.getStratum().get(i), i);
    }
  }

  protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent 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, "stratum", name, element, index);
    if (element.hasValue()) {
      composeType(t, "StratifierGroupComponent", "value", element.getValue(), -1);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeMeasureReportStratifierGroupComponentComponent(t, "StratifierGroupComponent", "component", element.getComponent().get(i), i);
    }
    for (int i = 0; i < element.getPopulation().size(); i++) {
      composeMeasureReportStratifierGroupPopulationComponent(t, "StratifierGroupComponent", "population", element.getPopulation().get(i), i);
    }
    if (element.hasMeasureScore()) {
      composeType(t, "StratifierGroupComponent", "measureScore", element.getMeasureScore(), -1);
    }
  }

  protected void composeMeasureReportStratifierGroupComponentComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponentComponent 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, "component", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "StratifierGroupComponentComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "StratifierGroupComponentComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "StratifierGroupComponentComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent 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, "population", name, element, index);
    if (element.hasLinkIdElement()) {
      composeString(t, "StratifierGroupPopulationComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "StratifierGroupPopulationComponent", "code", element.getCode(), -1);
    }
    if (element.hasCountElement()) {
      composeInteger(t, "StratifierGroupPopulationComponent", "count", element.getCountElement(), -1);
    }
    if (element.hasSubjectResults()) {
      composeReference(t, "StratifierGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
    }
    for (int i = 0; i < element.getSubjectReport().size(); i++) {
      composeReference(t, "StratifierGroupPopulationComponent", "subjectReport", element.getSubjectReport().get(i), i);
    }
    if (element.hasSubjects()) {
      composeReference(t, "StratifierGroupPopulationComponent", "subjects", element.getSubjects(), -1);
    }
  }

  protected void composeMedication(Complex parent, String parentType, String name, Medication 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, "Medication", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Medication", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Medication", "code", element.getCode(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Medication", "status", element.getStatusElement(), -1);
    }
    if (element.hasMarketingAuthorizationHolder()) {
      composeReference(t, "Medication", "marketingAuthorizationHolder", element.getMarketingAuthorizationHolder(), -1);
    }
    if (element.hasDoseForm()) {
      composeCodeableConcept(t, "Medication", "doseForm", element.getDoseForm(), -1);
    }
    if (element.hasTotalVolume()) {
      composeQuantity(t, "Medication", "totalVolume", element.getTotalVolume(), -1);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i);
    }
    if (element.hasBatch()) {
      composeMedicationBatchComponent(t, "Medication", "batch", element.getBatch(), -1);
    }
    if (element.hasDefinition()) {
      composeReference(t, "Medication", "definition", element.getDefinition(), -1);
    }
  }

  protected void composeMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent 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, "ingredient", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "MedicationIngredientComponent", "item", element.getItem(), -1);
    }
    if (element.hasIsActiveElement()) {
      composeBoolean(t, "MedicationIngredientComponent", "isActive", element.getIsActiveElement(), -1);
    }
    if (element.hasStrength()) {
      composeType(t, "MedicationIngredientComponent", "strength", element.getStrength(), -1);
    }
  }

  protected void composeMedicationBatchComponent(Complex parent, String parentType, String name, Medication.MedicationBatchComponent 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, "batch", name, element, index);
    if (element.hasLotNumberElement()) {
      composeString(t, "MedicationBatchComponent", "lotNumber", element.getLotNumberElement(), -1);
    }
    if (element.hasExpirationDateElement()) {
      composeDateTime(t, "MedicationBatchComponent", "expirationDate", element.getExpirationDateElement(), -1);
    }
  }

  protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration 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, "MedicationAdministration", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "MedicationAdministration", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getStatusReason().size(); i++) {
      composeCodeableConcept(t, "MedicationAdministration", "statusReason", element.getStatusReason().get(i), i);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory().get(i), i);
    }
    if (element.hasMedication()) {
      composeCodeableReference(t, "MedicationAdministration", "medication", element.getMedication(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "MedicationAdministration", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    if (element.hasOccurence()) {
      composeType(t, "MedicationAdministration", "occurence", element.getOccurence(), -1);
    }
    if (element.hasRecordedElement()) {
      composeDateTime(t, "MedicationAdministration", "recorded", element.getRecordedElement(), -1);
    }
    if (element.hasIsSubPotentElement()) {
      composeBoolean(t, "MedicationAdministration", "isSubPotent", element.getIsSubPotentElement(), -1);
    }
    for (int i = 0; i < element.getSubPotentReason().size(); i++) {
      composeCodeableConcept(t, "MedicationAdministration", "subPotentReason", element.getSubPotentReason().get(i), i);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "MedicationAdministration", "reason", element.getReason().get(i), i);
    }
    if (element.hasRequest()) {
      composeReference(t, "MedicationAdministration", "request", element.getRequest(), -1);
    }
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeCodeableReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i);
    }
    if (element.hasDosage()) {
      composeMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1);
    }
    for (int i = 0; i < element.getEventHistory().size(); i++) {
      composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i);
    }
  }

  protected void composeMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent 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, "MedicationAdministrationPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeCodeableReference(t, "MedicationAdministrationPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent 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, "dosage", name, element, index);
    if (element.hasTextElement()) {
      composeString(t, "MedicationAdministrationDosageComponent", "text", element.getTextElement(), -1);
    }
    if (element.hasSite()) {
      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "site", element.getSite(), -1);
    }
    if (element.hasRoute()) {
      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "route", element.getRoute(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "method", element.getMethod(), -1);
    }
    if (element.hasDose()) {
      composeQuantity(t, "MedicationAdministrationDosageComponent", "dose", element.getDose(), -1);
    }
    if (element.hasRate()) {
      composeType(t, "MedicationAdministrationDosageComponent", "rate", element.getRate(), -1);
    }
  }

  protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense 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, "MedicationDispense", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "MedicationDispense", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1);
    }
    if (element.hasNotPerformedReason()) {
      composeCodeableReference(t, "MedicationDispense", "notPerformedReason", element.getNotPerformedReason(), -1);
    }
    if (element.hasStatusChangedElement()) {
      composeDateTime(t, "MedicationDispense", "statusChanged", element.getStatusChangedElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory().get(i), i);
    }
    if (element.hasMedication()) {
      composeCodeableReference(t, "MedicationDispense", "medication", element.getMedication(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "MedicationDispense", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "MedicationDispense", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) {
      composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1);
    }
    if (element.hasDaysSupply()) {
      composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1);
    }
    if (element.hasRecordedElement()) {
      composeDateTime(t, "MedicationDispense", "recorded", element.getRecordedElement(), -1);
    }
    if (element.hasWhenPreparedElement()) {
      composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1);
    }
    if (element.hasWhenHandedOverElement()) {
      composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
    }
    if (element.hasDestination()) {
      composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1);
    }
    for (int i = 0; i < element.getReceiver().size(); i++) {
      composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i);
    }
    if (element.hasRenderedDosageInstructionElement()) {
      composeMarkdown(t, "MedicationDispense", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
    }
    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
      composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i);
    }
    if (element.hasSubstitution()) {
      composeMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1);
    }
    for (int i = 0; i < element.getEventHistory().size(); i++) {
      composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i);
    }
  }

  protected void composeMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent 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, "MedicationDispensePerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "MedicationDispensePerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent 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, "substitution", name, element, index);
    if (element.hasWasSubstitutedElement()) {
      composeBoolean(t, "MedicationDispenseSubstitutionComponent", "wasSubstituted", element.getWasSubstitutedElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "reason", element.getReason().get(i), i);
    }
    if (element.hasResponsibleParty()) {
      composeReference(t, "MedicationDispenseSubstitutionComponent", "responsibleParty", element.getResponsibleParty(), -1);
    }
  }

  protected void composeMedicationKnowledge(Complex parent, String parentType, String name, MedicationKnowledge 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, "MedicationKnowledge", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicationKnowledge", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "MedicationKnowledge", "code", element.getCode(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MedicationKnowledge", "status", element.getStatusElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "MedicationKnowledge", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getIntendedJurisdiction().size(); i++) {
      composeCodeableConcept(t, "MedicationKnowledge", "intendedJurisdiction", element.getIntendedJurisdiction().get(i), i);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeString(t, "MedicationKnowledge", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getRelatedMedicationKnowledge().size(); i++) {
      composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(t, "MedicationKnowledge", "relatedMedicationKnowledge", element.getRelatedMedicationKnowledge().get(i), i);
    }
    for (int i = 0; i < element.getAssociatedMedication().size(); i++) {
      composeReference(t, "MedicationKnowledge", "associatedMedication", element.getAssociatedMedication().get(i), i);
    }
    for (int i = 0; i < element.getProductType().size(); i++) {
      composeCodeableConcept(t, "MedicationKnowledge", "productType", element.getProductType().get(i), i);
    }
    for (int i = 0; i < element.getMonograph().size(); i++) {
      composeMedicationKnowledgeMonographComponent(t, "MedicationKnowledge", "monograph", element.getMonograph().get(i), i);
    }
    if (element.hasPreparationInstructionElement()) {
      composeMarkdown(t, "MedicationKnowledge", "preparationInstruction", element.getPreparationInstructionElement(), -1);
    }
    for (int i = 0; i < element.getCost().size(); i++) {
      composeMedicationKnowledgeCostComponent(t, "MedicationKnowledge", "cost", element.getCost().get(i), i);
    }
    for (int i = 0; i < element.getMonitoringProgram().size(); i++) {
      composeMedicationKnowledgeMonitoringProgramComponent(t, "MedicationKnowledge", "monitoringProgram", element.getMonitoringProgram().get(i), i);
    }
    for (int i = 0; i < element.getIndicationGuideline().size(); i++) {
      composeMedicationKnowledgeIndicationGuidelineComponent(t, "MedicationKnowledge", "indicationGuideline", element.getIndicationGuideline().get(i), i);
    }
    for (int i = 0; i < element.getMedicineClassification().size(); i++) {
      composeMedicationKnowledgeMedicineClassificationComponent(t, "MedicationKnowledge", "medicineClassification", element.getMedicineClassification().get(i), i);
    }
    for (int i = 0; i < element.getPackaging().size(); i++) {
      composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledge", "packaging", element.getPackaging().get(i), i);
    }
    for (int i = 0; i < element.getClinicalUseIssue().size(); i++) {
      composeReference(t, "MedicationKnowledge", "clinicalUseIssue", element.getClinicalUseIssue().get(i), i);
    }
    for (int i = 0; i < element.getStorageGuideline().size(); i++) {
      composeMedicationKnowledgeStorageGuidelineComponent(t, "MedicationKnowledge", "storageGuideline", element.getStorageGuideline().get(i), i);
    }
    for (int i = 0; i < element.getRegulatory().size(); i++) {
      composeMedicationKnowledgeRegulatoryComponent(t, "MedicationKnowledge", "regulatory", element.getRegulatory().get(i), i);
    }
    if (element.hasDefinitional()) {
      composeMedicationKnowledgeDefinitionalComponent(t, "MedicationKnowledge", "definitional", element.getDefinitional(), -1);
    }
  }

  protected void composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRelatedMedicationKnowledgeComponent 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, "relatedMedicationKnowledge", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getReference().size(); i++) {
      composeReference(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "reference", element.getReference().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeMonographComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonographComponent 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, "monograph", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeMonographComponent", "type", element.getType(), -1);
    }
    if (element.hasSource()) {
      composeReference(t, "MedicationKnowledgeMonographComponent", "source", element.getSource(), -1);
    }
  }

  protected void composeMedicationKnowledgeCostComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeCostComponent 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, "cost", name, element, index);
    for (int i = 0; i < element.getEffectiveDate().size(); i++) {
      composePeriod(t, "MedicationKnowledgeCostComponent", "effectiveDate", element.getEffectiveDate().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeCostComponent", "type", element.getType(), -1);
    }
    if (element.hasSourceElement()) {
      composeString(t, "MedicationKnowledgeCostComponent", "source", element.getSourceElement(), -1);
    }
    if (element.hasCost()) {
      composeType(t, "MedicationKnowledgeCostComponent", "cost", element.getCost(), -1);
    }
  }

  protected void composeMedicationKnowledgeMonitoringProgramComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonitoringProgramComponent 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, "monitoringProgram", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeMonitoringProgramComponent", "type", element.getType(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "MedicationKnowledgeMonitoringProgramComponent", "name", element.getNameElement(), -1);
    }
  }

  protected void composeMedicationKnowledgeIndicationGuidelineComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIndicationGuidelineComponent 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, "indicationGuideline", name, element, index);
    for (int i = 0; i < element.getIndication().size(); i++) {
      composeCodeableReference(t, "MedicationKnowledgeIndicationGuidelineComponent", "indication", element.getIndication().get(i), i);
    }
    for (int i = 0; i < element.getDosingGuideline().size(); i++) {
      composeMedicationKnowledgeIndicationGuidelineDosingGuidelineComponent(t, "MedicationKnowledgeIndicationGuidelineComponent", "dosingGuideline", element.getDosingGuideline().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeIndicationGuidelineDosingGuidelineComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIndicationGuidelineDosingGuidelineComponent 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, "dosingGuideline", name, element, index);
    if (element.hasTreatmentIntent()) {
      composeCodeableConcept(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineComponent", "treatmentIntent", element.getTreatmentIntent(), -1);
    }
    for (int i = 0; i < element.getDosage().size(); i++) {
      composeMedicationKnowledgeIndicationGuidelineDosingGuidelineDosageComponent(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineComponent", "dosage", element.getDosage().get(i), i);
    }
    if (element.hasAdministrationTreatment()) {
      composeCodeableConcept(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineComponent", "administrationTreatment", element.getAdministrationTreatment(), -1);
    }
    for (int i = 0; i < element.getPatientCharacteristic().size(); i++) {
      composeMedicationKnowledgeIndicationGuidelineDosingGuidelinePatientCharacteristicComponent(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineComponent", "patientCharacteristic", element.getPatientCharacteristic().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeIndicationGuidelineDosingGuidelineDosageComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIndicationGuidelineDosingGuidelineDosageComponent 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, "dosage", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineDosageComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getDosage().size(); i++) {
      composeDosage(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelineDosageComponent", "dosage", element.getDosage().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeIndicationGuidelineDosingGuidelinePatientCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIndicationGuidelineDosingGuidelinePatientCharacteristicComponent 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, "patientCharacteristic", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelinePatientCharacteristicComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "MedicationKnowledgeIndicationGuidelineDosingGuidelinePatientCharacteristicComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeMedicationKnowledgeMedicineClassificationComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMedicineClassificationComponent 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, "medicineClassification", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "type", element.getType(), -1);
    }
    if (element.hasSource()) {
      composeType(t, "MedicationKnowledgeMedicineClassificationComponent", "source", element.getSource(), -1);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "classification", element.getClassification().get(i), i);
    }
  }

  protected void composeMedicationKnowledgePackagingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgePackagingComponent 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, "packaging", name, element, index);
    for (int i = 0; i < element.getCost().size(); i++) {
      composeMedicationKnowledgeCostComponent(t, "MedicationKnowledgePackagingComponent", "cost", element.getCost().get(i), i);
    }
    if (element.hasPackagedProduct()) {
      composeReference(t, "MedicationKnowledgePackagingComponent", "packagedProduct", element.getPackagedProduct(), -1);
    }
  }

  protected void composeMedicationKnowledgeStorageGuidelineComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeStorageGuidelineComponent 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, "storageGuideline", name, element, index);
    if (element.hasReferenceElement()) {
      composeUri(t, "MedicationKnowledgeStorageGuidelineComponent", "reference", element.getReferenceElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "MedicationKnowledgeStorageGuidelineComponent", "note", element.getNote().get(i), i);
    }
    if (element.hasStabilityDuration()) {
      composeDuration(t, "MedicationKnowledgeStorageGuidelineComponent", "stabilityDuration", element.getStabilityDuration(), -1);
    }
    for (int i = 0; i < element.getEnvironmentalSetting().size(); i++) {
      composeMedicationKnowledgeStorageGuidelineEnvironmentalSettingComponent(t, "MedicationKnowledgeStorageGuidelineComponent", "environmentalSetting", element.getEnvironmentalSetting().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeStorageGuidelineEnvironmentalSettingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeStorageGuidelineEnvironmentalSettingComponent 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, "environmentalSetting", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeStorageGuidelineEnvironmentalSettingComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "MedicationKnowledgeStorageGuidelineEnvironmentalSettingComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeMedicationKnowledgeRegulatoryComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryComponent 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, "regulatory", name, element, index);
    if (element.hasRegulatoryAuthority()) {
      composeReference(t, "MedicationKnowledgeRegulatoryComponent", "regulatoryAuthority", element.getRegulatoryAuthority(), -1);
    }
    for (int i = 0; i < element.getSubstitution().size(); i++) {
      composeMedicationKnowledgeRegulatorySubstitutionComponent(t, "MedicationKnowledgeRegulatoryComponent", "substitution", element.getSubstitution().get(i), i);
    }
    for (int i = 0; i < element.getSchedule().size(); i++) {
      composeCodeableConcept(t, "MedicationKnowledgeRegulatoryComponent", "schedule", element.getSchedule().get(i), i);
    }
    if (element.hasMaxDispense()) {
      composeMedicationKnowledgeRegulatoryMaxDispenseComponent(t, "MedicationKnowledgeRegulatoryComponent", "maxDispense", element.getMaxDispense(), -1);
    }
  }

  protected void composeMedicationKnowledgeRegulatorySubstitutionComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatorySubstitutionComponent 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, "substitution", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "type", element.getType(), -1);
    }
    if (element.hasAllowedElement()) {
      composeBoolean(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "allowed", element.getAllowedElement(), -1);
    }
  }

  protected void composeMedicationKnowledgeRegulatoryMaxDispenseComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryMaxDispenseComponent 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, "maxDispense", name, element, index);
    if (element.hasQuantity()) {
      composeQuantity(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasPeriod()) {
      composeDuration(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeMedicationKnowledgeDefinitionalComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDefinitionalComponent 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, "definitional", name, element, index);
    for (int i = 0; i < element.getDefinition().size(); i++) {
      composeReference(t, "MedicationKnowledgeDefinitionalComponent", "definition", element.getDefinition().get(i), i);
    }
    if (element.hasDoseForm()) {
      composeCodeableConcept(t, "MedicationKnowledgeDefinitionalComponent", "doseForm", element.getDoseForm(), -1);
    }
    for (int i = 0; i < element.getIntendedRoute().size(); i++) {
      composeCodeableConcept(t, "MedicationKnowledgeDefinitionalComponent", "intendedRoute", element.getIntendedRoute().get(i), i);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeMedicationKnowledgeDefinitionalIngredientComponent(t, "MedicationKnowledgeDefinitionalComponent", "ingredient", element.getIngredient().get(i), i);
    }
    for (int i = 0; i < element.getDrugCharacteristic().size(); i++) {
      composeMedicationKnowledgeDefinitionalDrugCharacteristicComponent(t, "MedicationKnowledgeDefinitionalComponent", "drugCharacteristic", element.getDrugCharacteristic().get(i), i);
    }
  }

  protected void composeMedicationKnowledgeDefinitionalIngredientComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDefinitionalIngredientComponent 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, "ingredient", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "MedicationKnowledgeDefinitionalIngredientComponent", "item", element.getItem(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeDefinitionalIngredientComponent", "type", element.getType(), -1);
    }
    if (element.hasStrength()) {
      composeType(t, "MedicationKnowledgeDefinitionalIngredientComponent", "strength", element.getStrength(), -1);
    }
  }

  protected void composeMedicationKnowledgeDefinitionalDrugCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDefinitionalDrugCharacteristicComponent 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, "drugCharacteristic", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicationKnowledgeDefinitionalDrugCharacteristicComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "MedicationKnowledgeDefinitionalDrugCharacteristicComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest 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, "MedicationRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasPriorPrescription()) {
      composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "MedicationRequest", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasStatusChangedElement()) {
      composeDateTime(t, "MedicationRequest", "statusChanged", element.getStatusChangedElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory().get(i), i);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "MedicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasMedication()) {
      composeCodeableReference(t, "MedicationRequest", "medication", element.getMedication(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getInformationSource().size(); i++) {
      composeReference(t, "MedicationRequest", "informationSource", element.getInformationSource().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "MedicationRequest", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "MedicationRequest", "requester", element.getRequester(), -1);
    }
    if (element.hasReportedElement()) {
      composeBoolean(t, "MedicationRequest", "reported", element.getReportedElement(), -1);
    }
    if (element.hasPerformerType()) {
      composeCodeableConcept(t, "MedicationRequest", "performerType", element.getPerformerType(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeReference(t, "MedicationRequest", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeCodeableReference(t, "MedicationRequest", "device", element.getDevice().get(i), i);
    }
    if (element.hasRecorder()) {
      composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "MedicationRequest", "reason", element.getReason().get(i), i);
    }
    if (element.hasCourseOfTherapyType()) {
      composeCodeableConcept(t, "MedicationRequest", "courseOfTherapyType", element.getCourseOfTherapyType(), -1);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeReference(t, "MedicationRequest", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i);
    }
    if (element.hasRenderedDosageInstructionElement()) {
      composeMarkdown(t, "MedicationRequest", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
    }
    if (element.hasEffectiveDosePeriod()) {
      composePeriod(t, "MedicationRequest", "effectiveDosePeriod", element.getEffectiveDosePeriod(), -1);
    }
    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
      composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i);
    }
    if (element.hasDispenseRequest()) {
      composeMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1);
    }
    if (element.hasSubstitution()) {
      composeMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1);
    }
    for (int i = 0; i < element.getEventHistory().size(); i++) {
      composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i);
    }
  }

  protected void composeMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent 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, "dispenseRequest", name, element, index);
    if (element.hasInitialFill()) {
      composeMedicationRequestDispenseRequestInitialFillComponent(t, "MedicationRequestDispenseRequestComponent", "initialFill", element.getInitialFill(), -1);
    }
    if (element.hasDispenseInterval()) {
      composeDuration(t, "MedicationRequestDispenseRequestComponent", "dispenseInterval", element.getDispenseInterval(), -1);
    }
    if (element.hasValidityPeriod()) {
      composePeriod(t, "MedicationRequestDispenseRequestComponent", "validityPeriod", element.getValidityPeriod(), -1);
    }
    if (element.hasNumberOfRepeatsAllowedElement()) {
      composeUnsignedInt(t, "MedicationRequestDispenseRequestComponent", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "MedicationRequestDispenseRequestComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasExpectedSupplyDuration()) {
      composeDuration(t, "MedicationRequestDispenseRequestComponent", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1);
    }
    if (element.hasDispenser()) {
      composeReference(t, "MedicationRequestDispenseRequestComponent", "dispenser", element.getDispenser(), -1);
    }
    for (int i = 0; i < element.getDispenserInstruction().size(); i++) {
      composeAnnotation(t, "MedicationRequestDispenseRequestComponent", "dispenserInstruction", element.getDispenserInstruction().get(i), i);
    }
    if (element.hasDoseAdministrationAid()) {
      composeCodeableConcept(t, "MedicationRequestDispenseRequestComponent", "doseAdministrationAid", element.getDoseAdministrationAid(), -1);
    }
  }

  protected void composeMedicationRequestDispenseRequestInitialFillComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestInitialFillComponent 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, "initialFill", name, element, index);
    if (element.hasQuantity()) {
      composeQuantity(t, "MedicationRequestDispenseRequestInitialFillComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasDuration()) {
      composeDuration(t, "MedicationRequestDispenseRequestInitialFillComponent", "duration", element.getDuration(), -1);
    }
  }

  protected void composeMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent 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, "substitution", name, element, index);
    if (element.hasAllowed()) {
      composeType(t, "MedicationRequestSubstitutionComponent", "allowed", element.getAllowed(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "MedicationRequestSubstitutionComponent", "reason", element.getReason(), -1);
    }
  }

  protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement 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, "MedicationStatement", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory().get(i), i);
    }
    if (element.hasMedication()) {
      composeCodeableReference(t, "MedicationStatement", "medication", element.getMedication(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "MedicationStatement", "encounter", element.getEncounter(), -1);
    }
    if (element.hasEffective()) {
      composeType(t, "MedicationStatement", "effective", element.getEffective(), -1);
    }
    if (element.hasDateAssertedElement()) {
      composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1);
    }
    for (int i = 0; i < element.getInformationSource().size(); i++) {
      composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource().get(i), i);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "MedicationStatement", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getRelatedClinicalInformation().size(); i++) {
      composeReference(t, "MedicationStatement", "relatedClinicalInformation", element.getRelatedClinicalInformation().get(i), i);
    }
    if (element.hasRenderedDosageInstructionElement()) {
      composeMarkdown(t, "MedicationStatement", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
    }
    for (int i = 0; i < element.getDosage().size(); i++) {
      composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i);
    }
    if (element.hasAdherence()) {
      composeMedicationStatementAdherenceComponent(t, "MedicationStatement", "adherence", element.getAdherence(), -1);
    }
  }

  protected void composeMedicationStatementAdherenceComponent(Complex parent, String parentType, String name, MedicationStatement.MedicationStatementAdherenceComponent 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, "adherence", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "MedicationStatementAdherenceComponent", "code", element.getCode(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "MedicationStatementAdherenceComponent", "reason", element.getReason(), -1);
    }
  }

  protected void composeMedicinalProductDefinition(Complex parent, String parentType, String name, MedicinalProductDefinition 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, "MedicinalProductDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MedicinalProductDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "type", element.getType(), -1);
    }
    if (element.hasDomain()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "domain", element.getDomain(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "MedicinalProductDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "status", element.getStatus(), -1);
    }
    if (element.hasStatusDateElement()) {
      composeDateTime(t, "MedicinalProductDefinition", "statusDate", element.getStatusDateElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MedicinalProductDefinition", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCombinedPharmaceuticalDoseForm()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "combinedPharmaceuticalDoseForm", element.getCombinedPharmaceuticalDoseForm(), -1);
    }
    for (int i = 0; i < element.getRoute().size(); i++) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "route", element.getRoute().get(i), i);
    }
    if (element.hasIndicationElement()) {
      composeMarkdown(t, "MedicinalProductDefinition", "indication", element.getIndicationElement(), -1);
    }
    if (element.hasLegalStatusOfSupply()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1);
    }
    if (element.hasAdditionalMonitoringIndicator()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "additionalMonitoringIndicator", element.getAdditionalMonitoringIndicator(), -1);
    }
    for (int i = 0; i < element.getSpecialMeasures().size(); i++) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "specialMeasures", element.getSpecialMeasures().get(i), i);
    }
    if (element.hasPediatricUseIndicator()) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "pediatricUseIndicator", element.getPediatricUseIndicator(), -1);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "classification", element.getClassification().get(i), i);
    }
    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
      composeMarketingStatus(t, "MedicinalProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
    }
    for (int i = 0; i < element.getPackagedMedicinalProduct().size(); i++) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "packagedMedicinalProduct", element.getPackagedMedicinalProduct().get(i), i);
    }
    for (int i = 0; i < element.getComprisedOf().size(); i++) {
      composeReference(t, "MedicinalProductDefinition", "comprisedOf", element.getComprisedOf().get(i), i);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeCodeableConcept(t, "MedicinalProductDefinition", "ingredient", element.getIngredient().get(i), i);
    }
    for (int i = 0; i < element.getImpurity().size(); i++) {
      composeCodeableReference(t, "MedicinalProductDefinition", "impurity", element.getImpurity().get(i), i);
    }
    for (int i = 0; i < element.getAttachedDocument().size(); i++) {
      composeReference(t, "MedicinalProductDefinition", "attachedDocument", element.getAttachedDocument().get(i), i);
    }
    for (int i = 0; i < element.getMasterFile().size(); i++) {
      composeReference(t, "MedicinalProductDefinition", "masterFile", element.getMasterFile().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeMedicinalProductDefinitionContactComponent(t, "MedicinalProductDefinition", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getClinicalTrial().size(); i++) {
      composeReference(t, "MedicinalProductDefinition", "clinicalTrial", element.getClinicalTrial().get(i), i);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCoding(t, "MedicinalProductDefinition", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeMedicinalProductDefinitionNameComponent(t, "MedicinalProductDefinition", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getCrossReference().size(); i++) {
      composeMedicinalProductDefinitionCrossReferenceComponent(t, "MedicinalProductDefinition", "crossReference", element.getCrossReference().get(i), i);
    }
    for (int i = 0; i < element.getOperation().size(); i++) {
      composeMedicinalProductDefinitionOperationComponent(t, "MedicinalProductDefinition", "operation", element.getOperation().get(i), i);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeMedicinalProductDefinitionCharacteristicComponent(t, "MedicinalProductDefinition", "characteristic", element.getCharacteristic().get(i), i);
    }
  }

  protected void composeMedicinalProductDefinitionContactComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionContactComponent 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, "contact", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionContactComponent", "type", element.getType(), -1);
    }
    if (element.hasContact()) {
      composeReference(t, "MedicinalProductDefinitionContactComponent", "contact", element.getContact(), -1);
    }
  }

  protected void composeMedicinalProductDefinitionNameComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameComponent 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, "name", name, element, index);
    if (element.hasProductNameElement()) {
      composeString(t, "MedicinalProductDefinitionNameComponent", "productName", element.getProductNameElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionNameComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getPart().size(); i++) {
      composeMedicinalProductDefinitionNamePartComponent(t, "MedicinalProductDefinitionNameComponent", "part", element.getPart().get(i), i);
    }
    for (int i = 0; i < element.getUsage().size(); i++) {
      composeMedicinalProductDefinitionNameUsageComponent(t, "MedicinalProductDefinitionNameComponent", "usage", element.getUsage().get(i), i);
    }
  }

  protected void composeMedicinalProductDefinitionNamePartComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNamePartComponent 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.hasPartElement()) {
      composeString(t, "MedicinalProductDefinitionNamePartComponent", "part", element.getPartElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionNamePartComponent", "type", element.getType(), -1);
    }
  }

  protected void composeMedicinalProductDefinitionNameUsageComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameUsageComponent 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, "usage", name, element, index);
    if (element.hasCountry()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionNameUsageComponent", "country", element.getCountry(), -1);
    }
    if (element.hasJurisdiction()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionNameUsageComponent", "jurisdiction", element.getJurisdiction(), -1);
    }
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionNameUsageComponent", "language", element.getLanguage(), -1);
    }
  }

  protected void composeMedicinalProductDefinitionCrossReferenceComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCrossReferenceComponent 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, "crossReference", name, element, index);
    if (element.hasProduct()) {
      composeCodeableReference(t, "MedicinalProductDefinitionCrossReferenceComponent", "product", element.getProduct(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionCrossReferenceComponent", "type", element.getType(), -1);
    }
  }

  protected void composeMedicinalProductDefinitionOperationComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionOperationComponent 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.hasType()) {
      composeCodeableReference(t, "MedicinalProductDefinitionOperationComponent", "type", element.getType(), -1);
    }
    if (element.hasEffectiveDate()) {
      composePeriod(t, "MedicinalProductDefinitionOperationComponent", "effectiveDate", element.getEffectiveDate(), -1);
    }
    for (int i = 0; i < element.getOrganization().size(); i++) {
      composeReference(t, "MedicinalProductDefinitionOperationComponent", "organization", element.getOrganization().get(i), i);
    }
    if (element.hasConfidentialityIndicator()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionOperationComponent", "confidentialityIndicator", element.getConfidentialityIndicator(), -1);
    }
  }

  protected void composeMedicinalProductDefinitionCharacteristicComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "MedicinalProductDefinitionCharacteristicComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "MedicinalProductDefinitionCharacteristicComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition 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, "MessageDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "MessageDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "MessageDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeCanonical(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "MessageDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasBaseElement()) {
      composeCanonical(t, "MessageDefinition", "base", element.getBaseElement(), -1);
    }
    for (int i = 0; i < element.getParent().size(); i++) {
      composeCanonical(t, "MessageDefinition", "parent", element.getParent().get(i), i);
    }
    if (element.hasEvent()) {
      composeType(t, "MessageDefinition", "event", element.getEvent(), -1);
    }
    if (element.hasCategoryElement()) {
      composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i);
    }
    if (element.hasResponseRequiredElement()) {
      composeEnum(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1);
    }
    for (int i = 0; i < element.getAllowedResponse().size(); i++) {
      composeMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i);
    }
    if (element.hasGraphElement()) {
      composeCanonical(t, "MessageDefinition", "graph", element.getGraphElement(), -1);
    }
  }

  protected void composeMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent 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, "focus", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "MessageDefinitionFocusComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasProfileElement()) {
      composeCanonical(t, "MessageDefinitionFocusComponent", "profile", element.getProfileElement(), -1);
    }
    if (element.hasMinElement()) {
      composeUnsignedInt(t, "MessageDefinitionFocusComponent", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "MessageDefinitionFocusComponent", "max", element.getMaxElement(), -1);
    }
  }

  protected void composeMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent 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, "allowedResponse", name, element, index);
    if (element.hasMessageElement()) {
      composeCanonical(t, "MessageDefinitionAllowedResponseComponent", "message", element.getMessageElement(), -1);
    }
    if (element.hasSituationElement()) {
      composeMarkdown(t, "MessageDefinitionAllowedResponseComponent", "situation", element.getSituationElement(), -1);
    }
  }

  protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader 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, "MessageHeader", name, element, index);
    if (element.hasEvent()) {
      composeType(t, "MessageHeader", "event", element.getEvent(), -1);
    }
    for (int i = 0; i < element.getDestination().size(); i++) {
      composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i);
    }
    if (element.hasSender()) {
      composeReference(t, "MessageHeader", "sender", element.getSender(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "MessageHeader", "author", element.getAuthor(), -1);
    }
    if (element.hasSource()) {
      composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1);
    }
    if (element.hasResponsible()) {
      composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1);
    }
    if (element.hasResponse()) {
      composeMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i);
    }
    if (element.hasDefinitionElement()) {
      composeCanonical(t, "MessageHeader", "definition", element.getDefinitionElement(), -1);
    }
  }

  protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent 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, "destination", name, element, index);
    if (element.hasEndpoint()) {
      composeType(t, "MessageDestinationComponent", "endpoint", element.getEndpoint(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "MessageDestinationComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasTarget()) {
      composeReference(t, "MessageDestinationComponent", "target", element.getTarget(), -1);
    }
    if (element.hasReceiver()) {
      composeReference(t, "MessageDestinationComponent", "receiver", element.getReceiver(), -1);
    }
  }

  protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent 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.hasEndpoint()) {
      composeType(t, "MessageSourceComponent", "endpoint", element.getEndpoint(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "MessageSourceComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasSoftwareElement()) {
      composeString(t, "MessageSourceComponent", "software", element.getSoftwareElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "MessageSourceComponent", "version", element.getVersionElement(), -1);
    }
    if (element.hasContact()) {
      composeContactPoint(t, "MessageSourceComponent", "contact", element.getContact(), -1);
    }
  }

  protected void composeMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent 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.hasIdentifier()) {
      composeIdentifier(t, "MessageHeaderResponseComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasCodeElement()) {
      composeEnum(t, "MessageHeaderResponseComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDetails()) {
      composeReference(t, "MessageHeaderResponseComponent", "details", element.getDetails(), -1);
    }
  }

  protected void composeMolecularSequence(Complex parent, String parentType, String name, MolecularSequence 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, "MolecularSequence", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "MolecularSequence", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "MolecularSequence", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "MolecularSequence", "focus", element.getFocus().get(i), i);
    }
    if (element.hasSpecimen()) {
      composeReference(t, "MolecularSequence", "specimen", element.getSpecimen(), -1);
    }
    if (element.hasDevice()) {
      composeReference(t, "MolecularSequence", "device", element.getDevice(), -1);
    }
    if (element.hasPerformer()) {
      composeReference(t, "MolecularSequence", "performer", element.getPerformer(), -1);
    }
    if (element.hasLiteralElement()) {
      composeString(t, "MolecularSequence", "literal", element.getLiteralElement(), -1);
    }
    for (int i = 0; i < element.getFormatted().size(); i++) {
      composeAttachment(t, "MolecularSequence", "formatted", element.getFormatted().get(i), i);
    }
    for (int i = 0; i < element.getRelative().size(); i++) {
      composeMolecularSequenceRelativeComponent(t, "MolecularSequence", "relative", element.getRelative().get(i), i);
    }
  }

  protected void composeMolecularSequenceRelativeComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRelativeComponent 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, "relative", name, element, index);
    if (element.hasCoordinateSystem()) {
      composeCodeableConcept(t, "MolecularSequenceRelativeComponent", "coordinateSystem", element.getCoordinateSystem(), -1);
    }
    if (element.hasOrdinalPositionElement()) {
      composeInteger(t, "MolecularSequenceRelativeComponent", "ordinalPosition", element.getOrdinalPositionElement(), -1);
    }
    if (element.hasSequenceRange()) {
      composeRange(t, "MolecularSequenceRelativeComponent", "sequenceRange", element.getSequenceRange(), -1);
    }
    if (element.hasStartingSequence()) {
      composeMolecularSequenceRelativeStartingSequenceComponent(t, "MolecularSequenceRelativeComponent", "startingSequence", element.getStartingSequence(), -1);
    }
    for (int i = 0; i < element.getEdit().size(); i++) {
      composeMolecularSequenceRelativeEditComponent(t, "MolecularSequenceRelativeComponent", "edit", element.getEdit().get(i), i);
    }
  }

  protected void composeMolecularSequenceRelativeStartingSequenceComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRelativeStartingSequenceComponent 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, "startingSequence", name, element, index);
    if (element.hasGenomeAssembly()) {
      composeCodeableConcept(t, "MolecularSequenceRelativeStartingSequenceComponent", "genomeAssembly", element.getGenomeAssembly(), -1);
    }
    if (element.hasChromosome()) {
      composeCodeableConcept(t, "MolecularSequenceRelativeStartingSequenceComponent", "chromosome", element.getChromosome(), -1);
    }
    if (element.hasSequence()) {
      composeType(t, "MolecularSequenceRelativeStartingSequenceComponent", "sequence", element.getSequence(), -1);
    }
    if (element.hasWindowStartElement()) {
      composeInteger(t, "MolecularSequenceRelativeStartingSequenceComponent", "windowStart", element.getWindowStartElement(), -1);
    }
    if (element.hasWindowEndElement()) {
      composeInteger(t, "MolecularSequenceRelativeStartingSequenceComponent", "windowEnd", element.getWindowEndElement(), -1);
    }
    if (element.hasOrientationElement()) {
      composeEnum(t, "MolecularSequenceRelativeStartingSequenceComponent", "orientation", element.getOrientationElement(), -1);
    }
    if (element.hasStrandElement()) {
      composeEnum(t, "MolecularSequenceRelativeStartingSequenceComponent", "strand", element.getStrandElement(), -1);
    }
  }

  protected void composeMolecularSequenceRelativeEditComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRelativeEditComponent 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, "edit", name, element, index);
    if (element.hasStartElement()) {
      composeInteger(t, "MolecularSequenceRelativeEditComponent", "start", element.getStartElement(), -1);
    }
    if (element.hasEndElement()) {
      composeInteger(t, "MolecularSequenceRelativeEditComponent", "end", element.getEndElement(), -1);
    }
    if (element.hasReplacementSequenceElement()) {
      composeString(t, "MolecularSequenceRelativeEditComponent", "replacementSequence", element.getReplacementSequenceElement(), -1);
    }
    if (element.hasReplacedSequenceElement()) {
      composeString(t, "MolecularSequenceRelativeEditComponent", "replacedSequence", element.getReplacedSequenceElement(), -1);
    }
  }

  protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem 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, "NamingSystem", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "NamingSystem", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "NamingSystem", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "NamingSystem", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "NamingSystem", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "NamingSystem", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "NamingSystem", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "NamingSystem", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i);
    }
    if (element.hasResponsibleElement()) {
      composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "NamingSystem", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "NamingSystem", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "NamingSystem", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "NamingSystem", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "NamingSystem", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "NamingSystem", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "NamingSystem", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "NamingSystem", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "NamingSystem", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "NamingSystem", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "NamingSystem", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "NamingSystem", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasUsageElement()) {
      composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1);
    }
    for (int i = 0; i < element.getUniqueId().size(); i++) {
      composeNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i);
    }
  }

  protected void composeNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent 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, "uniqueId", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "NamingSystemUniqueIdComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "NamingSystemUniqueIdComponent", "value", element.getValueElement(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "NamingSystemUniqueIdComponent", "preferred", element.getPreferredElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeString(t, "NamingSystemUniqueIdComponent", "comment", element.getCommentElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "NamingSystemUniqueIdComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasAuthoritativeElement()) {
      composeBoolean(t, "NamingSystemUniqueIdComponent", "authoritative", element.getAuthoritativeElement(), -1);
    }
  }

  protected void composeNutritionIntake(Complex parent, String parentType, String name, NutritionIntake 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, "NutritionIntake", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "NutritionIntake", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "NutritionIntake", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "NutritionIntake", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "NutritionIntake", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "NutritionIntake", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "NutritionIntake", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getStatusReason().size(); i++) {
      composeCodeableConcept(t, "NutritionIntake", "statusReason", element.getStatusReason().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "NutritionIntake", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "NutritionIntake", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "NutritionIntake", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "NutritionIntake", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasRecordedElement()) {
      composeDateTime(t, "NutritionIntake", "recorded", element.getRecordedElement(), -1);
    }
    if (element.hasReported()) {
      composeType(t, "NutritionIntake", "reported", element.getReported(), -1);
    }
    for (int i = 0; i < element.getConsumedItem().size(); i++) {
      composeNutritionIntakeConsumedItemComponent(t, "NutritionIntake", "consumedItem", element.getConsumedItem().get(i), i);
    }
    for (int i = 0; i < element.getIngredientLabel().size(); i++) {
      composeNutritionIntakeIngredientLabelComponent(t, "NutritionIntake", "ingredientLabel", element.getIngredientLabel().get(i), i);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeNutritionIntakePerformerComponent(t, "NutritionIntake", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "NutritionIntake", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeReference(t, "NutritionIntake", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "NutritionIntake", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "NutritionIntake", "note", element.getNote().get(i), i);
    }
  }

  protected void composeNutritionIntakeConsumedItemComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeConsumedItemComponent 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, "consumedItem", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "type", element.getType(), -1);
    }
    if (element.hasNutritionProduct()) {
      composeCodeableReference(t, "NutritionIntakeConsumedItemComponent", "nutritionProduct", element.getNutritionProduct(), -1);
    }
    if (element.hasSchedule()) {
      composeTiming(t, "NutritionIntakeConsumedItemComponent", "schedule", element.getSchedule(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "NutritionIntakeConsumedItemComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasRate()) {
      composeQuantity(t, "NutritionIntakeConsumedItemComponent", "rate", element.getRate(), -1);
    }
    if (element.hasNotConsumedElement()) {
      composeBoolean(t, "NutritionIntakeConsumedItemComponent", "notConsumed", element.getNotConsumedElement(), -1);
    }
    if (element.hasNotConsumedReason()) {
      composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "notConsumedReason", element.getNotConsumedReason(), -1);
    }
  }

  protected void composeNutritionIntakeIngredientLabelComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeIngredientLabelComponent 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, "ingredientLabel", name, element, index);
    if (element.hasNutrient()) {
      composeCodeableReference(t, "NutritionIntakeIngredientLabelComponent", "nutrient", element.getNutrient(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "NutritionIntakeIngredientLabelComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeNutritionIntakePerformerComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakePerformerComponent 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, "NutritionIntakePerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "NutritionIntakePerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder 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, "NutritionOrder", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "NutritionOrder", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "NutritionOrder", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getInstantiates().size(); i++) {
      composeUri(t, "NutritionOrder", "instantiates", element.getInstantiates().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "NutritionOrder", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "NutritionOrder", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "NutritionOrder", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "NutritionOrder", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "NutritionOrder", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
      composeReference(t, "NutritionOrder", "supportingInformation", element.getSupportingInformation().get(i), i);
    }
    if (element.hasDateTimeElement()) {
      composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1);
    }
    if (element.hasOrderer()) {
      composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeCodeableReference(t, "NutritionOrder", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getAllergyIntolerance().size(); i++) {
      composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i);
    }
    for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) {
      composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i);
    }
    for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) {
      composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i);
    }
    if (element.hasOutsideFoodAllowedElement()) {
      composeBoolean(t, "NutritionOrder", "outsideFoodAllowed", element.getOutsideFoodAllowedElement(), -1);
    }
    if (element.hasOralDiet()) {
      composeNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1);
    }
    for (int i = 0; i < element.getSupplement().size(); i++) {
      composeNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i);
    }
    if (element.hasEnteralFormula()) {
      composeNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "NutritionOrder", "note", element.getNote().get(i), i);
    }
  }

  protected void composeNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent 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, "oralDiet", name, element, index);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "type", element.getType().get(i), i);
    }
    if (element.hasSchedule()) {
      composeNutritionOrderOralDietScheduleComponent(t, "NutritionOrderOralDietComponent", "schedule", element.getSchedule(), -1);
    }
    for (int i = 0; i < element.getNutrient().size(); i++) {
      composeNutritionOrderOralDietNutrientComponent(t, "NutritionOrderOralDietComponent", "nutrient", element.getNutrient().get(i), i);
    }
    for (int i = 0; i < element.getTexture().size(); i++) {
      composeNutritionOrderOralDietTextureComponent(t, "NutritionOrderOralDietComponent", "texture", element.getTexture().get(i), i);
    }
    for (int i = 0; i < element.getFluidConsistencyType().size(); i++) {
      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i);
    }
    if (element.hasInstructionElement()) {
      composeString(t, "NutritionOrderOralDietComponent", "instruction", element.getInstructionElement(), -1);
    }
  }

  protected void composeNutritionOrderOralDietScheduleComponent(Complex parent, String parentType, String name, NutritionOrder.OralDietScheduleComponent 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, "schedule", name, element, index);
    for (int i = 0; i < element.getTiming().size(); i++) {
      composeTiming(t, "OralDietScheduleComponent", "timing", element.getTiming().get(i), i);
    }
    if (element.hasAsNeededElement()) {
      composeBoolean(t, "OralDietScheduleComponent", "asNeeded", element.getAsNeededElement(), -1);
    }
    if (element.hasAsNeededFor()) {
      composeCodeableConcept(t, "OralDietScheduleComponent", "asNeededFor", element.getAsNeededFor(), -1);
    }
  }

  protected void composeNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent 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, "nutrient", name, element, index);
    if (element.hasModifier()) {
      composeCodeableConcept(t, "NutritionOrderOralDietNutrientComponent", "modifier", element.getModifier(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "NutritionOrderOralDietNutrientComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent 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, "texture", name, element, index);
    if (element.hasModifier()) {
      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "modifier", element.getModifier(), -1);
    }
    if (element.hasFoodType()) {
      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "foodType", element.getFoodType(), -1);
    }
  }

  protected void composeNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent 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, "supplement", name, element, index);
    if (element.hasType()) {
      composeCodeableReference(t, "NutritionOrderSupplementComponent", "type", element.getType(), -1);
    }
    if (element.hasProductNameElement()) {
      composeString(t, "NutritionOrderSupplementComponent", "productName", element.getProductNameElement(), -1);
    }
    if (element.hasSchedule()) {
      composeNutritionOrderSupplementScheduleComponent(t, "NutritionOrderSupplementComponent", "schedule", element.getSchedule(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "NutritionOrderSupplementComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasInstructionElement()) {
      composeString(t, "NutritionOrderSupplementComponent", "instruction", element.getInstructionElement(), -1);
    }
  }

  protected void composeNutritionOrderSupplementScheduleComponent(Complex parent, String parentType, String name, NutritionOrder.SupplementScheduleComponent 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, "schedule", name, element, index);
    for (int i = 0; i < element.getTiming().size(); i++) {
      composeTiming(t, "SupplementScheduleComponent", "timing", element.getTiming().get(i), i);
    }
    if (element.hasAsNeededElement()) {
      composeBoolean(t, "SupplementScheduleComponent", "asNeeded", element.getAsNeededElement(), -1);
    }
    if (element.hasAsNeededFor()) {
      composeCodeableConcept(t, "SupplementScheduleComponent", "asNeededFor", element.getAsNeededFor(), -1);
    }
  }

  protected void composeNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent 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, "enteralFormula", name, element, index);
    if (element.hasBaseFormulaType()) {
      composeCodeableReference(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaType", element.getBaseFormulaType(), -1);
    }
    if (element.hasBaseFormulaProductNameElement()) {
      composeString(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1);
    }
    for (int i = 0; i < element.getDeliveryDevice().size(); i++) {
      composeCodeableReference(t, "NutritionOrderEnteralFormulaComponent", "deliveryDevice", element.getDeliveryDevice().get(i), i);
    }
    for (int i = 0; i < element.getAdditive().size(); i++) {
      composeNutritionOrderEnteralFormulaAdditiveComponent(t, "NutritionOrderEnteralFormulaComponent", "additive", element.getAdditive().get(i), i);
    }
    if (element.hasCaloricDensity()) {
      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "caloricDensity", element.getCaloricDensity(), -1);
    }
    if (element.hasRouteOfAdministration()) {
      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "routeOfAdministration", element.getRouteOfAdministration(), -1);
    }
    for (int i = 0; i < element.getAdministration().size(); i++) {
      composeNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrderEnteralFormulaComponent", "administration", element.getAdministration().get(i), i);
    }
    if (element.hasMaxVolumeToDeliver()) {
      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1);
    }
    if (element.hasAdministrationInstructionElement()) {
      composeMarkdown(t, "NutritionOrderEnteralFormulaComponent", "administrationInstruction", element.getAdministrationInstructionElement(), -1);
    }
  }

  protected void composeNutritionOrderEnteralFormulaAdditiveComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdditiveComponent 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, "additive", name, element, index);
    if (element.hasType()) {
      composeCodeableReference(t, "NutritionOrderEnteralFormulaAdditiveComponent", "type", element.getType(), -1);
    }
    if (element.hasProductNameElement()) {
      composeString(t, "NutritionOrderEnteralFormulaAdditiveComponent", "productName", element.getProductNameElement(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "NutritionOrderEnteralFormulaAdditiveComponent", "quantity", element.getQuantity(), -1);
    }
  }

  protected void composeNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent 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, "administration", name, element, index);
    if (element.hasSchedule()) {
      composeNutritionOrderEnteralFormulaScheduleComponent(t, "NutritionOrderEnteralFormulaAdministrationComponent", "schedule", element.getSchedule(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "NutritionOrderEnteralFormulaAdministrationComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasRate()) {
      composeType(t, "NutritionOrderEnteralFormulaAdministrationComponent", "rate", element.getRate(), -1);
    }
  }

  protected void composeNutritionOrderEnteralFormulaScheduleComponent(Complex parent, String parentType, String name, NutritionOrder.EnteralFormulaScheduleComponent 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, "schedule", name, element, index);
    for (int i = 0; i < element.getTiming().size(); i++) {
      composeTiming(t, "EnteralFormulaScheduleComponent", "timing", element.getTiming().get(i), i);
    }
    if (element.hasAsNeededElement()) {
      composeBoolean(t, "EnteralFormulaScheduleComponent", "asNeeded", element.getAsNeededElement(), -1);
    }
    if (element.hasAsNeededFor()) {
      composeCodeableConcept(t, "EnteralFormulaScheduleComponent", "asNeededFor", element.getAsNeededFor(), -1);
    }
  }

  protected void composeNutritionProduct(Complex parent, String parentType, String name, NutritionProduct 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, "NutritionProduct", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "NutritionProduct", "code", element.getCode(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "NutritionProduct", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "NutritionProduct", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeReference(t, "NutritionProduct", "manufacturer", element.getManufacturer().get(i), i);
    }
    for (int i = 0; i < element.getNutrient().size(); i++) {
      composeNutritionProductNutrientComponent(t, "NutritionProduct", "nutrient", element.getNutrient().get(i), i);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeNutritionProductIngredientComponent(t, "NutritionProduct", "ingredient", element.getIngredient().get(i), i);
    }
    for (int i = 0; i < element.getKnownAllergen().size(); i++) {
      composeCodeableReference(t, "NutritionProduct", "knownAllergen", element.getKnownAllergen().get(i), i);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeNutritionProductCharacteristicComponent(t, "NutritionProduct", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getInstance().size(); i++) {
      composeNutritionProductInstanceComponent(t, "NutritionProduct", "instance", element.getInstance().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "NutritionProduct", "note", element.getNote().get(i), i);
    }
  }

  protected void composeNutritionProductNutrientComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductNutrientComponent 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, "nutrient", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "NutritionProductNutrientComponent", "item", element.getItem(), -1);
    }
    for (int i = 0; i < element.getAmount().size(); i++) {
      composeRatio(t, "NutritionProductNutrientComponent", "amount", element.getAmount().get(i), i);
    }
  }

  protected void composeNutritionProductIngredientComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductIngredientComponent 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, "ingredient", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "NutritionProductIngredientComponent", "item", element.getItem(), -1);
    }
    for (int i = 0; i < element.getAmount().size(); i++) {
      composeRatio(t, "NutritionProductIngredientComponent", "amount", element.getAmount().get(i), i);
    }
  }

  protected void composeNutritionProductCharacteristicComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductCharacteristicComponent 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, "characteristic", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "NutritionProductCharacteristicComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "NutritionProductCharacteristicComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeNutritionProductInstanceComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductInstanceComponent 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, "instance", name, element, index);
    if (element.hasQuantity()) {
      composeQuantity(t, "NutritionProductInstanceComponent", "quantity", element.getQuantity(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "NutritionProductInstanceComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "NutritionProductInstanceComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasLotNumberElement()) {
      composeString(t, "NutritionProductInstanceComponent", "lotNumber", element.getLotNumberElement(), -1);
    }
    if (element.hasExpiryElement()) {
      composeDateTime(t, "NutritionProductInstanceComponent", "expiry", element.getExpiryElement(), -1);
    }
    if (element.hasUseByElement()) {
      composeDateTime(t, "NutritionProductInstanceComponent", "useBy", element.getUseByElement(), -1);
    }
    if (element.hasBiologicalSourceEvent()) {
      composeIdentifier(t, "NutritionProductInstanceComponent", "biologicalSourceEvent", element.getBiologicalSourceEvent(), -1);
    }
  }

  protected void composeObservation(Complex parent, String parentType, String name, Observation 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, "Observation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasInstantiates()) {
      composeType(t, "Observation", "instantiates", element.getInstantiates(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getTriggeredBy().size(); i++) {
      composeObservationTriggeredByComponent(t, "Observation", "triggeredBy", element.getTriggeredBy().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "Observation", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Observation", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Observation", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Observation", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "Observation", "focus", element.getFocus().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Observation", "encounter", element.getEncounter(), -1);
    }
    if (element.hasEffective()) {
      composeType(t, "Observation", "effective", element.getEffective(), -1);
    }
    if (element.hasIssuedElement()) {
      composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeReference(t, "Observation", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasValue()) {
      composeType(t, "Observation", "value", element.getValue(), -1);
    }
    if (element.hasDataAbsentReason()) {
      composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1);
    }
    for (int i = 0; i < element.getInterpretation().size(); i++) {
      composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Observation", "note", element.getNote().get(i), i);
    }
    if (element.hasBodySite()) {
      composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1);
    }
    if (element.hasBodyStructure()) {
      composeReference(t, "Observation", "bodyStructure", element.getBodyStructure(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1);
    }
    if (element.hasSpecimen()) {
      composeReference(t, "Observation", "specimen", element.getSpecimen(), -1);
    }
    if (element.hasDevice()) {
      composeReference(t, "Observation", "device", element.getDevice(), -1);
    }
    for (int i = 0; i < element.getReferenceRange().size(); i++) {
      composeObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i);
    }
    for (int i = 0; i < element.getHasMember().size(); i++) {
      composeReference(t, "Observation", "hasMember", element.getHasMember().get(i), i);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeReference(t, "Observation", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeObservationTriggeredByComponent(Complex parent, String parentType, String name, Observation.ObservationTriggeredByComponent 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, "triggeredBy", name, element, index);
    if (element.hasObservation()) {
      composeReference(t, "ObservationTriggeredByComponent", "observation", element.getObservation(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "ObservationTriggeredByComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasReasonElement()) {
      composeString(t, "ObservationTriggeredByComponent", "reason", element.getReasonElement(), -1);
    }
  }

  protected void composeObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent 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, "referenceRange", name, element, index);
    if (element.hasLow()) {
      composeQuantity(t, "ObservationReferenceRangeComponent", "low", element.getLow(), -1);
    }
    if (element.hasHigh()) {
      composeQuantity(t, "ObservationReferenceRangeComponent", "high", element.getHigh(), -1);
    }
    if (element.hasNormalValue()) {
      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "normalValue", element.getNormalValue(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getAppliesTo().size(); i++) {
      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "appliesTo", element.getAppliesTo().get(i), i);
    }
    if (element.hasAge()) {
      composeRange(t, "ObservationReferenceRangeComponent", "age", element.getAge(), -1);
    }
    if (element.hasTextElement()) {
      composeMarkdown(t, "ObservationReferenceRangeComponent", "text", element.getTextElement(), -1);
    }
  }

  protected void composeObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent 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, "component", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "ObservationComponentComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ObservationComponentComponent", "value", element.getValue(), -1);
    }
    if (element.hasDataAbsentReason()) {
      composeCodeableConcept(t, "ObservationComponentComponent", "dataAbsentReason", element.getDataAbsentReason(), -1);
    }
    for (int i = 0; i < element.getInterpretation().size(); i++) {
      composeCodeableConcept(t, "ObservationComponentComponent", "interpretation", element.getInterpretation().get(i), i);
    }
    for (int i = 0; i < element.getReferenceRange().size(); i++) {
      composeObservationReferenceRangeComponent(t, "ObservationComponentComponent", "referenceRange", element.getReferenceRange().get(i), i);
    }
  }

  protected void composeObservationDefinition(Complex parent, String parentType, String name, ObservationDefinition 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, "ObservationDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ObservationDefinition", "url", element.getUrlElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "ObservationDefinition", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ObservationDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ObservationDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ObservationDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ObservationDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ObservationDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ObservationDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ObservationDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ObservationDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ObservationDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ObservationDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ObservationDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ObservationDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ObservationDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ObservationDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ObservationDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ObservationDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ObservationDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "ObservationDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) {
      composeCanonical(t, "ObservationDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i);
    }
    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
      composeUri(t, "ObservationDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeCodeableConcept(t, "ObservationDefinition", "subject", element.getSubject().get(i), i);
    }
    if (element.hasPerformerType()) {
      composeCodeableConcept(t, "ObservationDefinition", "performerType", element.getPerformerType(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "ObservationDefinition", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "ObservationDefinition", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getPermittedDataType().size(); i++) {
      composeEnum(t, "ObservationDefinition", "permittedDataType", element.getPermittedDataType().get(i), i);
    }
    if (element.hasMultipleResultsAllowedElement()) {
      composeBoolean(t, "ObservationDefinition", "multipleResultsAllowed", element.getMultipleResultsAllowedElement(), -1);
    }
    if (element.hasBodySite()) {
      composeCodeableConcept(t, "ObservationDefinition", "bodySite", element.getBodySite(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "ObservationDefinition", "method", element.getMethod(), -1);
    }
    for (int i = 0; i < element.getSpecimen().size(); i++) {
      composeReference(t, "ObservationDefinition", "specimen", element.getSpecimen().get(i), i);
    }
    for (int i = 0; i < element.getDevice().size(); i++) {
      composeReference(t, "ObservationDefinition", "device", element.getDevice().get(i), i);
    }
    if (element.hasPreferredReportNameElement()) {
      composeString(t, "ObservationDefinition", "preferredReportName", element.getPreferredReportNameElement(), -1);
    }
    for (int i = 0; i < element.getPermittedUnit().size(); i++) {
      composeCoding(t, "ObservationDefinition", "permittedUnit", element.getPermittedUnit().get(i), i);
    }
    for (int i = 0; i < element.getQualifiedValue().size(); i++) {
      composeObservationDefinitionQualifiedValueComponent(t, "ObservationDefinition", "qualifiedValue", element.getQualifiedValue().get(i), i);
    }
    for (int i = 0; i < element.getHasMember().size(); i++) {
      composeReference(t, "ObservationDefinition", "hasMember", element.getHasMember().get(i), i);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeObservationDefinitionComponentComponent(t, "ObservationDefinition", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeObservationDefinitionQualifiedValueComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQualifiedValueComponent 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, "qualifiedValue", name, element, index);
    if (element.hasContext()) {
      composeCodeableConcept(t, "ObservationDefinitionQualifiedValueComponent", "context", element.getContext(), -1);
    }
    for (int i = 0; i < element.getAppliesTo().size(); i++) {
      composeCodeableConcept(t, "ObservationDefinitionQualifiedValueComponent", "appliesTo", element.getAppliesTo().get(i), i);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "ObservationDefinitionQualifiedValueComponent", "gender", element.getGenderElement(), -1);
    }
    if (element.hasAge()) {
      composeRange(t, "ObservationDefinitionQualifiedValueComponent", "age", element.getAge(), -1);
    }
    if (element.hasGestationalAge()) {
      composeRange(t, "ObservationDefinitionQualifiedValueComponent", "gestationalAge", element.getGestationalAge(), -1);
    }
    if (element.hasConditionElement()) {
      composeString(t, "ObservationDefinitionQualifiedValueComponent", "condition", element.getConditionElement(), -1);
    }
    if (element.hasRangeCategoryElement()) {
      composeEnum(t, "ObservationDefinitionQualifiedValueComponent", "rangeCategory", element.getRangeCategoryElement(), -1);
    }
    if (element.hasRange()) {
      composeRange(t, "ObservationDefinitionQualifiedValueComponent", "range", element.getRange(), -1);
    }
    if (element.hasValidCodedValueSetElement()) {
      composeCanonical(t, "ObservationDefinitionQualifiedValueComponent", "validCodedValueSet", element.getValidCodedValueSetElement(), -1);
    }
    if (element.hasNormalCodedValueSetElement()) {
      composeCanonical(t, "ObservationDefinitionQualifiedValueComponent", "normalCodedValueSet", element.getNormalCodedValueSetElement(), -1);
    }
    if (element.hasAbnormalCodedValueSetElement()) {
      composeCanonical(t, "ObservationDefinitionQualifiedValueComponent", "abnormalCodedValueSet", element.getAbnormalCodedValueSetElement(), -1);
    }
    if (element.hasCriticalCodedValueSetElement()) {
      composeCanonical(t, "ObservationDefinitionQualifiedValueComponent", "criticalCodedValueSet", element.getCriticalCodedValueSetElement(), -1);
    }
  }

  protected void composeObservationDefinitionComponentComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionComponentComponent 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, "component", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "ObservationDefinitionComponentComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getPermittedDataType().size(); i++) {
      composeEnum(t, "ObservationDefinitionComponentComponent", "permittedDataType", element.getPermittedDataType().get(i), i);
    }
    for (int i = 0; i < element.getPermittedUnit().size(); i++) {
      composeCoding(t, "ObservationDefinitionComponentComponent", "permittedUnit", element.getPermittedUnit().get(i), i);
    }
    for (int i = 0; i < element.getQualifiedValue().size(); i++) {
      composeObservationDefinitionQualifiedValueComponent(t, "ObservationDefinitionComponentComponent", "qualifiedValue", element.getQualifiedValue().get(i), i);
    }
  }

  protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition 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, "OperationDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "OperationDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "OperationDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "OperationDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "OperationDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "OperationDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "OperationDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasAffectsStateElement()) {
      composeBoolean(t, "OperationDefinition", "affectsState", element.getAffectsStateElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "OperationDefinition", "comment", element.getCommentElement(), -1);
    }
    if (element.hasBaseElement()) {
      composeCanonical(t, "OperationDefinition", "base", element.getBaseElement(), -1);
    }
    for (int i = 0; i < element.getResource().size(); i++) {
      composeEnum(t, "OperationDefinition", "resource", element.getResource().get(i), i);
    }
    if (element.hasSystemElement()) {
      composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1);
    }
    if (element.hasInstanceElement()) {
      composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1);
    }
    if (element.hasInputProfileElement()) {
      composeCanonical(t, "OperationDefinition", "inputProfile", element.getInputProfileElement(), -1);
    }
    if (element.hasOutputProfileElement()) {
      composeCanonical(t, "OperationDefinition", "outputProfile", element.getOutputProfileElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i);
    }
    for (int i = 0; i < element.getOverload().size(); i++) {
      composeOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i);
    }
  }

  protected void composeOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent 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, "parameter", name, element, index);
    if (element.hasNameElement()) {
      composeCode(t, "OperationDefinitionParameterComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasUseElement()) {
      composeEnum(t, "OperationDefinitionParameterComponent", "use", element.getUseElement(), -1);
    }
    for (int i = 0; i < element.getScope().size(); i++) {
      composeEnum(t, "OperationDefinitionParameterComponent", "scope", element.getScope().get(i), i);
    }
    if (element.hasMinElement()) {
      composeInteger(t, "OperationDefinitionParameterComponent", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "OperationDefinitionParameterComponent", "max", element.getMaxElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeMarkdown(t, "OperationDefinitionParameterComponent", "documentation", element.getDocumentationElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "OperationDefinitionParameterComponent", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getAllowedType().size(); i++) {
      composeEnum(t, "OperationDefinitionParameterComponent", "allowedType", element.getAllowedType().get(i), i);
    }
    for (int i = 0; i < element.getTargetProfile().size(); i++) {
      composeCanonical(t, "OperationDefinitionParameterComponent", "targetProfile", element.getTargetProfile().get(i), i);
    }
    if (element.hasSearchTypeElement()) {
      composeEnum(t, "OperationDefinitionParameterComponent", "searchType", element.getSearchTypeElement(), -1);
    }
    if (element.hasBinding()) {
      composeOperationDefinitionParameterBindingComponent(t, "OperationDefinitionParameterComponent", "binding", element.getBinding(), -1);
    }
    for (int i = 0; i < element.getReferencedFrom().size(); i++) {
      composeOperationDefinitionParameterReferencedFromComponent(t, "OperationDefinitionParameterComponent", "referencedFrom", element.getReferencedFrom().get(i), i);
    }
    for (int i = 0; i < element.getPart().size(); i++) {
      composeOperationDefinitionParameterComponent(t, "OperationDefinitionParameterComponent", "part", element.getPart().get(i), i);
    }
  }

  protected void composeOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent 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, "binding", name, element, index);
    if (element.hasStrengthElement()) {
      composeEnum(t, "OperationDefinitionParameterBindingComponent", "strength", element.getStrengthElement(), -1);
    }
    if (element.hasValueSetElement()) {
      composeCanonical(t, "OperationDefinitionParameterBindingComponent", "valueSet", element.getValueSetElement(), -1);
    }
  }

  protected void composeOperationDefinitionParameterReferencedFromComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterReferencedFromComponent 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, "referencedFrom", name, element, index);
    if (element.hasSourceElement()) {
      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "source", element.getSourceElement(), -1);
    }
    if (element.hasSourceIdElement()) {
      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "sourceId", element.getSourceIdElement(), -1);
    }
  }

  protected void composeOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent 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, "overload", name, element, index);
    for (int i = 0; i < element.getParameterName().size(); i++) {
      composeString(t, "OperationDefinitionOverloadComponent", "parameterName", element.getParameterName().get(i), i);
    }
    if (element.hasCommentElement()) {
      composeString(t, "OperationDefinitionOverloadComponent", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome 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, "OperationOutcome", name, element, index);
    for (int i = 0; i < element.getIssue().size(); i++) {
      composeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i);
    }
  }

  protected void composeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent 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, "issue", name, element, index);
    if (element.hasSeverityElement()) {
      composeEnum(t, "OperationOutcomeIssueComponent", "severity", element.getSeverityElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeEnum(t, "OperationOutcomeIssueComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDetails()) {
      composeCodeableConcept(t, "OperationOutcomeIssueComponent", "details", element.getDetails(), -1);
    }
    if (element.hasDiagnosticsElement()) {
      composeString(t, "OperationOutcomeIssueComponent", "diagnostics", element.getDiagnosticsElement(), -1);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeString(t, "OperationOutcomeIssueComponent", "location", element.getLocation().get(i), i);
    }
    for (int i = 0; i < element.getExpression().size(); i++) {
      composeString(t, "OperationOutcomeIssueComponent", "expression", element.getExpression().get(i), i);
    }
  }

  protected void composeOrganization(Complex parent, String parentType, String name, Organization 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, "Organization", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Organization", "active", element.getActiveElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Organization", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getAlias().size(); i++) {
      composeString(t, "Organization", "alias", element.getAlias().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Organization", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "Organization", "contact", element.getContact().get(i), i);
    }
    if (element.hasPartOf()) {
      composeReference(t, "Organization", "partOf", element.getPartOf(), -1);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i);
    }
    for (int i = 0; i < element.getQualification().size(); i++) {
      composeOrganizationQualificationComponent(t, "Organization", "qualification", element.getQualification().get(i), i);
    }
  }

  protected void composeOrganizationQualificationComponent(Complex parent, String parentType, String name, Organization.OrganizationQualificationComponent 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, "qualification", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "OrganizationQualificationComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "OrganizationQualificationComponent", "code", element.getCode(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "OrganizationQualificationComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasIssuer()) {
      composeReference(t, "OrganizationQualificationComponent", "issuer", element.getIssuer(), -1);
    }
  }

  protected void composeOrganizationAffiliation(Complex parent, String parentType, String name, OrganizationAffiliation 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, "OrganizationAffiliation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "OrganizationAffiliation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "OrganizationAffiliation", "active", element.getActiveElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "OrganizationAffiliation", "period", element.getPeriod(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "OrganizationAffiliation", "organization", element.getOrganization(), -1);
    }
    if (element.hasParticipatingOrganization()) {
      composeReference(t, "OrganizationAffiliation", "participatingOrganization", element.getParticipatingOrganization(), -1);
    }
    for (int i = 0; i < element.getNetwork().size(); i++) {
      composeReference(t, "OrganizationAffiliation", "network", element.getNetwork().get(i), i);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "OrganizationAffiliation", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "OrganizationAffiliation", "specialty", element.getSpecialty().get(i), i);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeReference(t, "OrganizationAffiliation", "location", element.getLocation().get(i), i);
    }
    for (int i = 0; i < element.getHealthcareService().size(); i++) {
      composeReference(t, "OrganizationAffiliation", "healthcareService", element.getHealthcareService().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "OrganizationAffiliation", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "OrganizationAffiliation", "endpoint", element.getEndpoint().get(i), i);
    }
  }

  protected void composePackagedProductDefinition(Complex parent, String parentType, String name, PackagedProductDefinition 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, "PackagedProductDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PackagedProductDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "PackagedProductDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PackagedProductDefinition", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getPackageFor().size(); i++) {
      composeReference(t, "PackagedProductDefinition", "packageFor", element.getPackageFor().get(i), i);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "PackagedProductDefinition", "status", element.getStatus(), -1);
    }
    if (element.hasStatusDateElement()) {
      composeDateTime(t, "PackagedProductDefinition", "statusDate", element.getStatusDateElement(), -1);
    }
    for (int i = 0; i < element.getContainedItemQuantity().size(); i++) {
      composeQuantity(t, "PackagedProductDefinition", "containedItemQuantity", element.getContainedItemQuantity().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "PackagedProductDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getLegalStatusOfSupply().size(); i++) {
      composePackagedProductDefinitionLegalStatusOfSupplyComponent(t, "PackagedProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply().get(i), i);
    }
    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
      composeMarketingStatus(t, "PackagedProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
    }
    if (element.hasCopackagedIndicatorElement()) {
      composeBoolean(t, "PackagedProductDefinition", "copackagedIndicator", element.getCopackagedIndicatorElement(), -1);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeReference(t, "PackagedProductDefinition", "manufacturer", element.getManufacturer().get(i), i);
    }
    for (int i = 0; i < element.getAttachedDocument().size(); i++) {
      composeReference(t, "PackagedProductDefinition", "attachedDocument", element.getAttachedDocument().get(i), i);
    }
    if (element.hasPackaging()) {
      composePackagedProductDefinitionPackagingComponent(t, "PackagedProductDefinition", "packaging", element.getPackaging(), -1);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composePackagedProductDefinitionPackagingPropertyComponent(t, "PackagedProductDefinition", "characteristic", element.getCharacteristic().get(i), i);
    }
  }

  protected void composePackagedProductDefinitionLegalStatusOfSupplyComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionLegalStatusOfSupplyComponent 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, "legalStatusOfSupply", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "PackagedProductDefinitionLegalStatusOfSupplyComponent", "code", element.getCode(), -1);
    }
    if (element.hasJurisdiction()) {
      composeCodeableConcept(t, "PackagedProductDefinitionLegalStatusOfSupplyComponent", "jurisdiction", element.getJurisdiction(), -1);
    }
  }

  protected void composePackagedProductDefinitionPackagingComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackagingComponent 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, "packaging", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PackagedProductDefinitionPackagingComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PackagedProductDefinitionPackagingComponent", "type", element.getType(), -1);
    }
    if (element.hasComponentPartElement()) {
      composeBoolean(t, "PackagedProductDefinitionPackagingComponent", "componentPart", element.getComponentPartElement(), -1);
    }
    if (element.hasQuantityElement()) {
      composeInteger(t, "PackagedProductDefinitionPackagingComponent", "quantity", element.getQuantityElement(), -1);
    }
    for (int i = 0; i < element.getMaterial().size(); i++) {
      composeCodeableConcept(t, "PackagedProductDefinitionPackagingComponent", "material", element.getMaterial().get(i), i);
    }
    for (int i = 0; i < element.getAlternateMaterial().size(); i++) {
      composeCodeableConcept(t, "PackagedProductDefinitionPackagingComponent", "alternateMaterial", element.getAlternateMaterial().get(i), i);
    }
    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
      composeProductShelfLife(t, "PackagedProductDefinitionPackagingComponent", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeReference(t, "PackagedProductDefinitionPackagingComponent", "manufacturer", element.getManufacturer().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composePackagedProductDefinitionPackagingPropertyComponent(t, "PackagedProductDefinitionPackagingComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getContainedItem().size(); i++) {
      composePackagedProductDefinitionPackagingContainedItemComponent(t, "PackagedProductDefinitionPackagingComponent", "containedItem", element.getContainedItem().get(i), i);
    }
    for (int i = 0; i < element.getPackaging().size(); i++) {
      composePackagedProductDefinitionPackagingComponent(t, "PackagedProductDefinitionPackagingComponent", "packaging", element.getPackaging().get(i), i);
    }
  }

  protected void composePackagedProductDefinitionPackagingPropertyComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackagingPropertyComponent 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, "PackagedProductDefinitionPackagingPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "PackagedProductDefinitionPackagingPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composePackagedProductDefinitionPackagingContainedItemComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackagingContainedItemComponent 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, "containedItem", name, element, index);
    if (element.hasItem()) {
      composeCodeableReference(t, "PackagedProductDefinitionPackagingContainedItemComponent", "item", element.getItem(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "PackagedProductDefinitionPackagingContainedItemComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeParameters(Complex parent, String parentType, String name, Parameters 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, "Parameters", name, element, index);
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i);
    }
  }

  protected void composeParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent 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, "parameter", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ParametersParameterComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ParametersParameterComponent", "value", element.getValue(), -1);
    }
    if (element.hasResource()) {
      composeResource(t, "ParametersParameterComponent", "resource", element.getResource(), -1);
    }
    for (int i = 0; i < element.getPart().size(); i++) {
      composeParametersParameterComponent(t, "ParametersParameterComponent", "part", element.getPart().get(i), i);
    }
  }

  protected void composePatient(Complex parent, String parentType, String name, Patient 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, "Patient", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Patient", "active", element.getActiveElement(), -1);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeHumanName(t, "Patient", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "Patient", "gender", element.getGenderElement(), -1);
    }
    if (element.hasBirthDateElement()) {
      composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1);
    }
    if (element.hasDeceased()) {
      composeType(t, "Patient", "deceased", element.getDeceased(), -1);
    }
    for (int i = 0; i < element.getAddress().size(); i++) {
      composeAddress(t, "Patient", "address", element.getAddress().get(i), i);
    }
    if (element.hasMaritalStatus()) {
      composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1);
    }
    if (element.hasMultipleBirth()) {
      composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1);
    }
    for (int i = 0; i < element.getPhoto().size(); i++) {
      composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composePatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i);
    }
    for (int i = 0; i < element.getGeneralPractitioner().size(); i++) {
      composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i);
    }
    if (element.hasManagingOrganization()) {
      composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composePatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i);
    }
  }

  protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent 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, "contact", name, element, index);
    for (int i = 0; i < element.getRelationship().size(); i++) {
      composeCodeableConcept(t, "ContactComponent", "relationship", element.getRelationship().get(i), i);
    }
    if (element.hasName()) {
      composeHumanName(t, "ContactComponent", "name", element.getName(), -1);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "ContactComponent", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasAddress()) {
      composeAddress(t, "ContactComponent", "address", element.getAddress(), -1);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "ContactComponent", "gender", element.getGenderElement(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "ContactComponent", "organization", element.getOrganization(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ContactComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composePatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent 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, "communication", name, element, index);
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "PatientCommunicationComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "PatientCommunicationComponent", "preferred", element.getPreferredElement(), -1);
    }
  }

  protected void composePatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent 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.hasOther()) {
      composeReference(t, "PatientLinkComponent", "other", element.getOther(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "PatientLinkComponent", "type", element.getTypeElement(), -1);
    }
  }

  protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice 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, "PaymentNotice", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1);
    }
    if (element.hasRequest()) {
      composeReference(t, "PaymentNotice", "request", element.getRequest(), -1);
    }
    if (element.hasResponse()) {
      composeReference(t, "PaymentNotice", "response", element.getResponse(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1);
    }
    if (element.hasReporter()) {
      composeReference(t, "PaymentNotice", "reporter", element.getReporter(), -1);
    }
    if (element.hasPayment()) {
      composeReference(t, "PaymentNotice", "payment", element.getPayment(), -1);
    }
    if (element.hasPaymentDateElement()) {
      composeDate(t, "PaymentNotice", "paymentDate", element.getPaymentDateElement(), -1);
    }
    if (element.hasPayee()) {
      composeReference(t, "PaymentNotice", "payee", element.getPayee(), -1);
    }
    if (element.hasRecipient()) {
      composeReference(t, "PaymentNotice", "recipient", element.getRecipient(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "PaymentNotice", "amount", element.getAmount(), -1);
    }
    if (element.hasPaymentStatus()) {
      composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1);
    }
  }

  protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation 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, "PaymentReconciliation", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1);
    }
    if (element.hasKind()) {
      composeCodeableConcept(t, "PaymentReconciliation", "kind", element.getKind(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1);
    }
    if (element.hasEnterer()) {
      composeReference(t, "PaymentReconciliation", "enterer", element.getEnterer(), -1);
    }
    if (element.hasIssuerType()) {
      composeCodeableConcept(t, "PaymentReconciliation", "issuerType", element.getIssuerType(), -1);
    }
    if (element.hasPaymentIssuer()) {
      composeReference(t, "PaymentReconciliation", "paymentIssuer", element.getPaymentIssuer(), -1);
    }
    if (element.hasRequest()) {
      composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1);
    }
    if (element.hasRequestor()) {
      composeReference(t, "PaymentReconciliation", "requestor", element.getRequestor(), -1);
    }
    if (element.hasOutcomeElement()) {
      composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1);
    }
    if (element.hasDispositionElement()) {
      composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDate(t, "PaymentReconciliation", "date", element.getDateElement(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "PaymentReconciliation", "location", element.getLocation(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "PaymentReconciliation", "method", element.getMethod(), -1);
    }
    if (element.hasCardBrandElement()) {
      composeString(t, "PaymentReconciliation", "cardBrand", element.getCardBrandElement(), -1);
    }
    if (element.hasAccountNumberElement()) {
      composeString(t, "PaymentReconciliation", "accountNumber", element.getAccountNumberElement(), -1);
    }
    if (element.hasExpirationDateElement()) {
      composeDate(t, "PaymentReconciliation", "expirationDate", element.getExpirationDateElement(), -1);
    }
    if (element.hasProcessorElement()) {
      composeString(t, "PaymentReconciliation", "processor", element.getProcessorElement(), -1);
    }
    if (element.hasReferenceNumberElement()) {
      composeString(t, "PaymentReconciliation", "referenceNumber", element.getReferenceNumberElement(), -1);
    }
    if (element.hasAuthorizationElement()) {
      composeString(t, "PaymentReconciliation", "authorization", element.getAuthorizationElement(), -1);
    }
    if (element.hasTenderedAmount()) {
      composeMoney(t, "PaymentReconciliation", "tenderedAmount", element.getTenderedAmount(), -1);
    }
    if (element.hasReturnedAmount()) {
      composeMoney(t, "PaymentReconciliation", "returnedAmount", element.getReturnedAmount(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "PaymentReconciliation", "amount", element.getAmount(), -1);
    }
    if (element.hasPaymentIdentifier()) {
      composeIdentifier(t, "PaymentReconciliation", "paymentIdentifier", element.getPaymentIdentifier(), -1);
    }
    for (int i = 0; i < element.getAllocation().size(); i++) {
      composePaymentReconciliationAllocationComponent(t, "PaymentReconciliation", "allocation", element.getAllocation().get(i), i);
    }
    if (element.hasFormCode()) {
      composeCodeableConcept(t, "PaymentReconciliation", "formCode", element.getFormCode(), -1);
    }
    for (int i = 0; i < element.getProcessNote().size(); i++) {
      composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i);
    }
  }

  protected void composePaymentReconciliationAllocationComponent(Complex parent, String parentType, String name, PaymentReconciliation.PaymentReconciliationAllocationComponent 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, "allocation", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "PaymentReconciliationAllocationComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasPredecessor()) {
      composeIdentifier(t, "PaymentReconciliationAllocationComponent", "predecessor", element.getPredecessor(), -1);
    }
    if (element.hasTarget()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "target", element.getTarget(), -1);
    }
    if (element.hasTargetItem()) {
      composeType(t, "PaymentReconciliationAllocationComponent", "targetItem", element.getTargetItem(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "encounter", element.getEncounter(), -1);
    }
    if (element.hasAccount()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "account", element.getAccount(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PaymentReconciliationAllocationComponent", "type", element.getType(), -1);
    }
    if (element.hasSubmitter()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "submitter", element.getSubmitter(), -1);
    }
    if (element.hasResponse()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "response", element.getResponse(), -1);
    }
    if (element.hasDateElement()) {
      composeDate(t, "PaymentReconciliationAllocationComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasResponsible()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "responsible", element.getResponsible(), -1);
    }
    if (element.hasPayee()) {
      composeReference(t, "PaymentReconciliationAllocationComponent", "payee", element.getPayee(), -1);
    }
    if (element.hasAmount()) {
      composeMoney(t, "PaymentReconciliationAllocationComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent 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.hasTypeElement()) {
      composeEnum(t, "NotesComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "NotesComponent", "text", element.getTextElement(), -1);
    }
  }

  protected void composePermission(Complex parent, String parentType, String name, Permission 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, "Permission", name, element, index);
    if (element.hasStatusElement()) {
      composeEnum(t, "Permission", "status", element.getStatusElement(), -1);
    }
    if (element.hasAsserter()) {
      composeReference(t, "Permission", "asserter", element.getAsserter(), -1);
    }
    for (int i = 0; i < element.getDate().size(); i++) {
      composeDateTime(t, "Permission", "date", element.getDate().get(i), i);
    }
    if (element.hasValidity()) {
      composePeriod(t, "Permission", "validity", element.getValidity(), -1);
    }
    if (element.hasJustification()) {
      composePermissionJustificationComponent(t, "Permission", "justification", element.getJustification(), -1);
    }
    if (element.hasCombiningElement()) {
      composeEnum(t, "Permission", "combining", element.getCombiningElement(), -1);
    }
    for (int i = 0; i < element.getRule().size(); i++) {
      composePermissionRuleComponent(t, "Permission", "rule", element.getRule().get(i), i);
    }
  }

  protected void composePermissionJustificationComponent(Complex parent, String parentType, String name, Permission.PermissionJustificationComponent 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, "justification", name, element, index);
    for (int i = 0; i < element.getBasis().size(); i++) {
      composeCodeableConcept(t, "PermissionJustificationComponent", "basis", element.getBasis().get(i), i);
    }
    for (int i = 0; i < element.getEvidence().size(); i++) {
      composeReference(t, "PermissionJustificationComponent", "evidence", element.getEvidence().get(i), i);
    }
  }

  protected void composePermissionRuleComponent(Complex parent, String parentType, String name, Permission.RuleComponent 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.hasTypeElement()) {
      composeEnum(t, "RuleComponent", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getData().size(); i++) {
      composePermissionRuleDataComponent(t, "RuleComponent", "data", element.getData().get(i), i);
    }
    for (int i = 0; i < element.getActivity().size(); i++) {
      composePermissionRuleActivityComponent(t, "RuleComponent", "activity", element.getActivity().get(i), i);
    }
    for (int i = 0; i < element.getLimit().size(); i++) {
      composeCodeableConcept(t, "RuleComponent", "limit", element.getLimit().get(i), i);
    }
  }

  protected void composePermissionRuleDataComponent(Complex parent, String parentType, String name, Permission.RuleDataComponent 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);
    for (int i = 0; i < element.getResource().size(); i++) {
      composePermissionRuleDataResourceComponent(t, "RuleDataComponent", "resource", element.getResource().get(i), i);
    }
    for (int i = 0; i < element.getSecurity().size(); i++) {
      composeCoding(t, "RuleDataComponent", "security", element.getSecurity().get(i), i);
    }
    for (int i = 0; i < element.getPeriod().size(); i++) {
      composePeriod(t, "RuleDataComponent", "period", element.getPeriod().get(i), i);
    }
    if (element.hasExpression()) {
      composeExpression(t, "RuleDataComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composePermissionRuleDataResourceComponent(Complex parent, String parentType, String name, Permission.RuleDataResourceComponent 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.hasMeaningElement()) {
      composeEnum(t, "RuleDataResourceComponent", "meaning", element.getMeaningElement(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "RuleDataResourceComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composePermissionRuleActivityComponent(Complex parent, String parentType, String name, Permission.RuleActivityComponent 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.getActor().size(); i++) {
      composeReference(t, "RuleActivityComponent", "actor", element.getActor().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeCodeableConcept(t, "RuleActivityComponent", "action", element.getAction().get(i), i);
    }
    for (int i = 0; i < element.getPurpose().size(); i++) {
      composeCodeableConcept(t, "RuleActivityComponent", "purpose", element.getPurpose().get(i), i);
    }
  }

  protected void composePerson(Complex parent, String parentType, String name, Person 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, "Person", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Person", "active", element.getActiveElement(), -1);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeHumanName(t, "Person", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "Person", "gender", element.getGenderElement(), -1);
    }
    if (element.hasBirthDateElement()) {
      composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1);
    }
    if (element.hasDeceased()) {
      composeType(t, "Person", "deceased", element.getDeceased(), -1);
    }
    for (int i = 0; i < element.getAddress().size(); i++) {
      composeAddress(t, "Person", "address", element.getAddress().get(i), i);
    }
    if (element.hasMaritalStatus()) {
      composeCodeableConcept(t, "Person", "maritalStatus", element.getMaritalStatus(), -1);
    }
    for (int i = 0; i < element.getPhoto().size(); i++) {
      composeAttachment(t, "Person", "photo", element.getPhoto().get(i), i);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composePersonCommunicationComponent(t, "Person", "communication", element.getCommunication().get(i), i);
    }
    if (element.hasManagingOrganization()) {
      composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composePersonLinkComponent(t, "Person", "link", element.getLink().get(i), i);
    }
  }

  protected void composePersonCommunicationComponent(Complex parent, String parentType, String name, Person.PersonCommunicationComponent 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, "communication", name, element, index);
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "PersonCommunicationComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "PersonCommunicationComponent", "preferred", element.getPreferredElement(), -1);
    }
  }

  protected void composePersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent 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.hasTarget()) {
      composeReference(t, "PersonLinkComponent", "target", element.getTarget(), -1);
    }
    if (element.hasAssuranceElement()) {
      composeEnum(t, "PersonLinkComponent", "assurance", element.getAssuranceElement(), -1);
    }
  }

  protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition 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, "PlanDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "PlanDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "PlanDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasSubtitleElement()) {
      composeString(t, "PlanDefinition", "subtitle", element.getSubtitleElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "PlanDefinition", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasUsageElement()) {
      composeMarkdown(t, "PlanDefinition", "usage", element.getUsageElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "PlanDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "PlanDefinition", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "PlanDefinition", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "PlanDefinition", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "PlanDefinition", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    for (int i = 0; i < element.getLibrary().size(); i++) {
      composeCanonical(t, "PlanDefinition", "library", element.getLibrary().get(i), i);
    }
    for (int i = 0; i < element.getGoal().size(); i++) {
      composePlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i);
    }
    for (int i = 0; i < element.getActor().size(); i++) {
      composePlanDefinitionActorComponent(t, "PlanDefinition", "actor", element.getActor().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composePlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i);
    }
    if (element.hasAsNeeded()) {
      composeType(t, "PlanDefinition", "asNeeded", element.getAsNeeded(), -1);
    }
  }

  protected void composePlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent 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, "goal", name, element, index);
    if (element.hasCategory()) {
      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "category", element.getCategory(), -1);
    }
    if (element.hasDescription()) {
      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "description", element.getDescription(), -1);
    }
    if (element.hasPriority()) {
      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "priority", element.getPriority(), -1);
    }
    if (element.hasStart()) {
      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "start", element.getStart(), -1);
    }
    for (int i = 0; i < element.getAddresses().size(); i++) {
      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "addresses", element.getAddresses().get(i), i);
    }
    for (int i = 0; i < element.getDocumentation().size(); i++) {
      composeRelatedArtifact(t, "PlanDefinitionGoalComponent", "documentation", element.getDocumentation().get(i), i);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composePlanDefinitionGoalTargetComponent(t, "PlanDefinitionGoalComponent", "target", element.getTarget().get(i), i);
    }
  }

  protected void composePlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent 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.hasMeasure()) {
      composeCodeableConcept(t, "PlanDefinitionGoalTargetComponent", "measure", element.getMeasure(), -1);
    }
    if (element.hasDetail()) {
      composeType(t, "PlanDefinitionGoalTargetComponent", "detail", element.getDetail(), -1);
    }
    if (element.hasDue()) {
      composeDuration(t, "PlanDefinitionGoalTargetComponent", "due", element.getDue(), -1);
    }
  }

  protected void composePlanDefinitionActorComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActorComponent 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.hasTitleElement()) {
      composeString(t, "PlanDefinitionActorComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "PlanDefinitionActorComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getOption().size(); i++) {
      composePlanDefinitionActorOptionComponent(t, "PlanDefinitionActorComponent", "option", element.getOption().get(i), i);
    }
  }

  protected void composePlanDefinitionActorOptionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActorOptionComponent 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, "option", name, element, index);
    if (element.hasTypeElement()) {
      composeEnum(t, "PlanDefinitionActorOptionComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTypeCanonicalElement()) {
      composeCanonical(t, "PlanDefinitionActorOptionComponent", "typeCanonical", element.getTypeCanonicalElement(), -1);
    }
    if (element.hasTypeReference()) {
      composeReference(t, "PlanDefinitionActorOptionComponent", "typeReference", element.getTypeReference(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "PlanDefinitionActorOptionComponent", "role", element.getRole(), -1);
    }
  }

  protected void composePlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent 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.hasLinkIdElement()) {
      composeString(t, "PlanDefinitionActionComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasPrefixElement()) {
      composeString(t, "PlanDefinitionActionComponent", "prefix", element.getPrefixElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "PlanDefinitionActionComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "PlanDefinitionActionComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTextEquivalentElement()) {
      composeMarkdown(t, "PlanDefinitionActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "PlanDefinitionActionComponent", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableConcept(t, "PlanDefinitionActionComponent", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getDocumentation().size(); i++) {
      composeRelatedArtifact(t, "PlanDefinitionActionComponent", "documentation", element.getDocumentation().get(i), i);
    }
    for (int i = 0; i < element.getGoalId().size(); i++) {
      composeId(t, "PlanDefinitionActionComponent", "goalId", element.getGoalId().get(i), i);
    }
    if (element.hasSubject()) {
      composeType(t, "PlanDefinitionActionComponent", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getTrigger().size(); i++) {
      composeTriggerDefinition(t, "PlanDefinitionActionComponent", "trigger", element.getTrigger().get(i), i);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composePlanDefinitionActionConditionComponent(t, "PlanDefinitionActionComponent", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composePlanDefinitionActionInputComponent(t, "PlanDefinitionActionComponent", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getOutput().size(); i++) {
      composePlanDefinitionActionOutputComponent(t, "PlanDefinitionActionComponent", "output", element.getOutput().get(i), i);
    }
    for (int i = 0; i < element.getRelatedAction().size(); i++) {
      composePlanDefinitionActionRelatedActionComponent(t, "PlanDefinitionActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
    }
    if (element.hasTiming()) {
      composeType(t, "PlanDefinitionActionComponent", "timing", element.getTiming(), -1);
    }
    if (element.hasLocation()) {
      composeCodeableReference(t, "PlanDefinitionActionComponent", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composePlanDefinitionActionParticipantComponent(t, "PlanDefinitionActionComponent", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "PlanDefinitionActionComponent", "type", element.getType(), -1);
    }
    if (element.hasGroupingBehaviorElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
    }
    if (element.hasSelectionBehaviorElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
    }
    if (element.hasRequiredBehaviorElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
    }
    if (element.hasPrecheckBehaviorElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
    }
    if (element.hasCardinalityBehaviorElement()) {
      composeEnum(t, "PlanDefinitionActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
    }
    if (element.hasDefinition()) {
      composeType(t, "PlanDefinitionActionComponent", "definition", element.getDefinition(), -1);
    }
    if (element.hasTransformElement()) {
      composeCanonical(t, "PlanDefinitionActionComponent", "transform", element.getTransformElement(), -1);
    }
    for (int i = 0; i < element.getDynamicValue().size(); i++) {
      composePlanDefinitionActionDynamicValueComponent(t, "PlanDefinitionActionComponent", "dynamicValue", element.getDynamicValue().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composePlanDefinitionActionComponent(t, "PlanDefinitionActionComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composePlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent 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, "condition", name, element, index);
    if (element.hasKindElement()) {
      composeEnum(t, "PlanDefinitionActionConditionComponent", "kind", element.getKindElement(), -1);
    }
    if (element.hasExpression()) {
      composeExpression(t, "PlanDefinitionActionConditionComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composePlanDefinitionActionInputComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionInputComponent 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, "input", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "PlanDefinitionActionInputComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasRequirement()) {
      composeDataRequirement(t, "PlanDefinitionActionInputComponent", "requirement", element.getRequirement(), -1);
    }
    if (element.hasRelatedDataElement()) {
      composeId(t, "PlanDefinitionActionInputComponent", "relatedData", element.getRelatedDataElement(), -1);
    }
  }

  protected void composePlanDefinitionActionOutputComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionOutputComponent 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, "output", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "PlanDefinitionActionOutputComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasRequirement()) {
      composeDataRequirement(t, "PlanDefinitionActionOutputComponent", "requirement", element.getRequirement(), -1);
    }
    if (element.hasRelatedDataElement()) {
      composeString(t, "PlanDefinitionActionOutputComponent", "relatedData", element.getRelatedDataElement(), -1);
    }
  }

  protected void composePlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent 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, "relatedAction", name, element, index);
    if (element.hasTargetIdElement()) {
      composeId(t, "PlanDefinitionActionRelatedActionComponent", "targetId", element.getTargetIdElement(), -1);
    }
    if (element.hasRelationshipElement()) {
      composeEnum(t, "PlanDefinitionActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
    }
    if (element.hasEndRelationshipElement()) {
      composeEnum(t, "PlanDefinitionActionRelatedActionComponent", "endRelationship", element.getEndRelationshipElement(), -1);
    }
    if (element.hasOffset()) {
      composeType(t, "PlanDefinitionActionRelatedActionComponent", "offset", element.getOffset(), -1);
    }
  }

  protected void composePlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent 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.hasActorIdElement()) {
      composeString(t, "PlanDefinitionActionParticipantComponent", "actorId", element.getActorIdElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "PlanDefinitionActionParticipantComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTypeCanonicalElement()) {
      composeCanonical(t, "PlanDefinitionActionParticipantComponent", "typeCanonical", element.getTypeCanonicalElement(), -1);
    }
    if (element.hasTypeReference()) {
      composeReference(t, "PlanDefinitionActionParticipantComponent", "typeReference", element.getTypeReference(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "PlanDefinitionActionParticipantComponent", "role", element.getRole(), -1);
    }
    if (element.hasFunction()) {
      composeCodeableConcept(t, "PlanDefinitionActionParticipantComponent", "function", element.getFunction(), -1);
    }
  }

  protected void composePlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent 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, "PlanDefinitionActionDynamicValueComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasExpression()) {
      composeExpression(t, "PlanDefinitionActionDynamicValueComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composePractitioner(Complex parent, String parentType, String name, Practitioner 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, "Practitioner", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeHumanName(t, "Practitioner", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1);
    }
    if (element.hasBirthDateElement()) {
      composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1);
    }
    if (element.hasDeceased()) {
      composeType(t, "Practitioner", "deceased", element.getDeceased(), -1);
    }
    for (int i = 0; i < element.getAddress().size(); i++) {
      composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i);
    }
    for (int i = 0; i < element.getPhoto().size(); i++) {
      composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i);
    }
    for (int i = 0; i < element.getQualification().size(); i++) {
      composePractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composePractitionerCommunicationComponent(t, "Practitioner", "communication", element.getCommunication().get(i), i);
    }
  }

  protected void composePractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent 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, "qualification", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PractitionerQualificationComponent", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "PractitionerQualificationComponent", "code", element.getCode(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "PractitionerQualificationComponent", "period", element.getPeriod(), -1);
    }
    if (element.hasIssuer()) {
      composeReference(t, "PractitionerQualificationComponent", "issuer", element.getIssuer(), -1);
    }
  }

  protected void composePractitionerCommunicationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerCommunicationComponent 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, "communication", name, element, index);
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "PractitionerCommunicationComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "PractitionerCommunicationComponent", "preferred", element.getPreferredElement(), -1);
    }
  }

  protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole 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, "PractitionerRole", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1);
    }
    if (element.hasPractitioner()) {
      composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1);
    }
    if (element.hasOrganization()) {
      composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i);
    }
    for (int i = 0; i < element.getHealthcareService().size(); i++) {
      composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeExtendedContactDetail(t, "PractitionerRole", "contact", element.getContact().get(i), i);
    }
    for (int i = 0; i < element.getCharacteristic().size(); i++) {
      composeCodeableConcept(t, "PractitionerRole", "characteristic", element.getCharacteristic().get(i), i);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composeCodeableConcept(t, "PractitionerRole", "communication", element.getCommunication().get(i), i);
    }
    for (int i = 0; i < element.getAvailability().size(); i++) {
      composeAvailability(t, "PractitionerRole", "availability", element.getAvailability().get(i), i);
    }
    for (int i = 0; i < element.getEndpoint().size(); i++) {
      composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i);
    }
  }

  protected void composeProcedure(Complex parent, String parentType, String name, Procedure 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, "Procedure", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "Procedure", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "Procedure", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Procedure", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "Procedure", "statusReason", element.getStatusReason(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Procedure", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Procedure", "subject", element.getSubject(), -1);
    }
    if (element.hasFocus()) {
      composeReference(t, "Procedure", "focus", element.getFocus(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Procedure", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "Procedure", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasRecordedElement()) {
      composeDateTime(t, "Procedure", "recorded", element.getRecordedElement(), -1);
    }
    if (element.hasRecorder()) {
      composeReference(t, "Procedure", "recorder", element.getRecorder(), -1);
    }
    if (element.hasReported()) {
      composeType(t, "Procedure", "reported", element.getReported(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "Procedure", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "Procedure", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i);
    }
    if (element.hasOutcome()) {
      composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1);
    }
    for (int i = 0; i < element.getReport().size(); i++) {
      composeReference(t, "Procedure", "report", element.getReport().get(i), i);
    }
    for (int i = 0; i < element.getComplication().size(); i++) {
      composeCodeableReference(t, "Procedure", "complication", element.getComplication().get(i), i);
    }
    for (int i = 0; i < element.getFollowUp().size(); i++) {
      composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getFocalDevice().size(); i++) {
      composeProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i);
    }
    for (int i = 0; i < element.getUsed().size(); i++) {
      composeCodeableReference(t, "Procedure", "used", element.getUsed().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeReference(t, "Procedure", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
  }

  protected void composeProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent 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, "ProcedurePerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "ProcedurePerformerComponent", "actor", element.getActor(), -1);
    }
    if (element.hasOnBehalfOf()) {
      composeReference(t, "ProcedurePerformerComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ProcedurePerformerComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent 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, "focalDevice", name, element, index);
    if (element.hasAction()) {
      composeCodeableConcept(t, "ProcedureFocalDeviceComponent", "action", element.getAction(), -1);
    }
    if (element.hasManipulated()) {
      composeReference(t, "ProcedureFocalDeviceComponent", "manipulated", element.getManipulated(), -1);
    }
  }

  protected void composeProvenance(Complex parent, String parentType, String name, Provenance 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, "Provenance", name, element, index);
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeReference(t, "Provenance", "target", element.getTarget().get(i), i);
    }
    if (element.hasOccurred()) {
      composeType(t, "Provenance", "occurred", element.getOccurred(), -1);
    }
    if (element.hasRecordedElement()) {
      composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1);
    }
    for (int i = 0; i < element.getPolicy().size(); i++) {
      composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "Provenance", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getAuthorization().size(); i++) {
      composeCodeableReference(t, "Provenance", "authorization", element.getAuthorization().get(i), i);
    }
    if (element.hasActivity()) {
      composeCodeableConcept(t, "Provenance", "activity", element.getActivity(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Provenance", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasPatient()) {
      composeReference(t, "Provenance", "patient", element.getPatient(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Provenance", "encounter", element.getEncounter(), -1);
    }
    for (int i = 0; i < element.getAgent().size(); i++) {
      composeProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i);
    }
    for (int i = 0; i < element.getEntity().size(); i++) {
      composeProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i);
    }
    for (int i = 0; i < element.getSignature().size(); i++) {
      composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i);
    }
  }

  protected void composeProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent 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, "ProvenanceAgentComponent", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getRole().size(); i++) {
      composeCodeableConcept(t, "ProvenanceAgentComponent", "role", element.getRole().get(i), i);
    }
    if (element.hasWho()) {
      composeReference(t, "ProvenanceAgentComponent", "who", element.getWho(), -1);
    }
    if (element.hasOnBehalfOf()) {
      composeReference(t, "ProvenanceAgentComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
    }
  }

  protected void composeProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent 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.hasRoleElement()) {
      composeEnum(t, "ProvenanceEntityComponent", "role", element.getRoleElement(), -1);
    }
    if (element.hasWhat()) {
      composeReference(t, "ProvenanceEntityComponent", "what", element.getWhat(), -1);
    }
    for (int i = 0; i < element.getAgent().size(); i++) {
      composeProvenanceAgentComponent(t, "ProvenanceEntityComponent", "agent", element.getAgent().get(i), i);
    }
  }

  protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire 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, "Questionnaire", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Questionnaire", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Questionnaire", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Questionnaire", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Questionnaire", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeCanonical(t, "Questionnaire", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1);
    }
    for (int i = 0; i < element.getSubjectType().size(); i++) {
      composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Questionnaire", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i);
    }
  }

  protected void composeQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent 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.hasLinkIdElement()) {
      composeString(t, "QuestionnaireItemComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeUri(t, "QuestionnaireItemComponent", "definition", element.getDefinitionElement(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCoding(t, "QuestionnaireItemComponent", "code", element.getCode().get(i), i);
    }
    if (element.hasPrefixElement()) {
      composeString(t, "QuestionnaireItemComponent", "prefix", element.getPrefixElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "QuestionnaireItemComponent", "text", element.getTextElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "QuestionnaireItemComponent", "type", element.getTypeElement(), -1);
    }
    for (int i = 0; i < element.getEnableWhen().size(); i++) {
      composeQuestionnaireItemEnableWhenComponent(t, "QuestionnaireItemComponent", "enableWhen", element.getEnableWhen().get(i), i);
    }
    if (element.hasEnableBehaviorElement()) {
      composeEnum(t, "QuestionnaireItemComponent", "enableBehavior", element.getEnableBehaviorElement(), -1);
    }
    if (element.hasDisabledDisplayElement()) {
      composeEnum(t, "QuestionnaireItemComponent", "disabledDisplay", element.getDisabledDisplayElement(), -1);
    }
    if (element.hasRequiredElement()) {
      composeBoolean(t, "QuestionnaireItemComponent", "required", element.getRequiredElement(), -1);
    }
    if (element.hasRepeatsElement()) {
      composeBoolean(t, "QuestionnaireItemComponent", "repeats", element.getRepeatsElement(), -1);
    }
    if (element.hasReadOnlyElement()) {
      composeBoolean(t, "QuestionnaireItemComponent", "readOnly", element.getReadOnlyElement(), -1);
    }
    if (element.hasMaxLengthElement()) {
      composeInteger(t, "QuestionnaireItemComponent", "maxLength", element.getMaxLengthElement(), -1);
    }
    if (element.hasAnswerConstraintElement()) {
      composeEnum(t, "QuestionnaireItemComponent", "answerConstraint", element.getAnswerConstraintElement(), -1);
    }
    if (element.hasAnswerValueSetElement()) {
      composeCanonical(t, "QuestionnaireItemComponent", "answerValueSet", element.getAnswerValueSetElement(), -1);
    }
    for (int i = 0; i < element.getAnswerOption().size(); i++) {
      composeQuestionnaireItemAnswerOptionComponent(t, "QuestionnaireItemComponent", "answerOption", element.getAnswerOption().get(i), i);
    }
    for (int i = 0; i < element.getInitial().size(); i++) {
      composeQuestionnaireItemInitialComponent(t, "QuestionnaireItemComponent", "initial", element.getInitial().get(i), i);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeQuestionnaireItemComponent(t, "QuestionnaireItemComponent", "item", element.getItem().get(i), i);
    }
  }

  protected void composeQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent 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, "enableWhen", name, element, index);
    if (element.hasQuestionElement()) {
      composeString(t, "QuestionnaireItemEnableWhenComponent", "question", element.getQuestionElement(), -1);
    }
    if (element.hasOperatorElement()) {
      composeEnum(t, "QuestionnaireItemEnableWhenComponent", "operator", element.getOperatorElement(), -1);
    }
    if (element.hasAnswer()) {
      composeType(t, "QuestionnaireItemEnableWhenComponent", "answer", element.getAnswer(), -1);
    }
  }

  protected void composeQuestionnaireItemAnswerOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemAnswerOptionComponent 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, "answerOption", name, element, index);
    if (element.hasValue()) {
      composeType(t, "QuestionnaireItemAnswerOptionComponent", "value", element.getValue(), -1);
    }
    if (element.hasInitialSelectedElement()) {
      composeBoolean(t, "QuestionnaireItemAnswerOptionComponent", "initialSelected", element.getInitialSelectedElement(), -1);
    }
  }

  protected void composeQuestionnaireItemInitialComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemInitialComponent 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, "initial", name, element, index);
    if (element.hasValue()) {
      composeType(t, "QuestionnaireItemInitialComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse 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, "QuestionnaireResponse", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "QuestionnaireResponse", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasQuestionnaireElement()) {
      composeCanonical(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaireElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1);
    }
    if (element.hasAuthoredElement()) {
      composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1);
    }
    if (element.hasSource()) {
      composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i);
    }
  }

  protected void composeQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent 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.hasLinkIdElement()) {
      composeString(t, "QuestionnaireResponseItemComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasDefinitionElement()) {
      composeUri(t, "QuestionnaireResponseItemComponent", "definition", element.getDefinitionElement(), -1);
    }
    if (element.hasTextElement()) {
      composeString(t, "QuestionnaireResponseItemComponent", "text", element.getTextElement(), -1);
    }
    for (int i = 0; i < element.getAnswer().size(); i++) {
      composeQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponseItemComponent", "answer", element.getAnswer().get(i), i);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemComponent", "item", element.getItem().get(i), i);
    }
  }

  protected void composeQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent 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, "QuestionnaireResponseItemAnswerComponent", "value", element.getValue(), -1);
    }
    for (int i = 0; i < element.getItem().size(); i++) {
      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemAnswerComponent", "item", element.getItem().get(i), i);
    }
  }

  protected void composeRegulatedAuthorization(Complex parent, String parentType, String name, RegulatedAuthorization 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, "RegulatedAuthorization", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "RegulatedAuthorization", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getSubject().size(); i++) {
      composeReference(t, "RegulatedAuthorization", "subject", element.getSubject().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "RegulatedAuthorization", "type", element.getType(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "RegulatedAuthorization", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getRegion().size(); i++) {
      composeCodeableConcept(t, "RegulatedAuthorization", "region", element.getRegion().get(i), i);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "RegulatedAuthorization", "status", element.getStatus(), -1);
    }
    if (element.hasStatusDateElement()) {
      composeDateTime(t, "RegulatedAuthorization", "statusDate", element.getStatusDateElement(), -1);
    }
    if (element.hasValidityPeriod()) {
      composePeriod(t, "RegulatedAuthorization", "validityPeriod", element.getValidityPeriod(), -1);
    }
    for (int i = 0; i < element.getIndication().size(); i++) {
      composeCodeableReference(t, "RegulatedAuthorization", "indication", element.getIndication().get(i), i);
    }
    if (element.hasIntendedUse()) {
      composeCodeableConcept(t, "RegulatedAuthorization", "intendedUse", element.getIntendedUse(), -1);
    }
    for (int i = 0; i < element.getBasis().size(); i++) {
      composeCodeableConcept(t, "RegulatedAuthorization", "basis", element.getBasis().get(i), i);
    }
    if (element.hasHolder()) {
      composeReference(t, "RegulatedAuthorization", "holder", element.getHolder(), -1);
    }
    if (element.hasRegulator()) {
      composeReference(t, "RegulatedAuthorization", "regulator", element.getRegulator(), -1);
    }
    for (int i = 0; i < element.getAttachedDocument().size(); i++) {
      composeReference(t, "RegulatedAuthorization", "attachedDocument", element.getAttachedDocument().get(i), i);
    }
    if (element.hasCase()) {
      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorization", "case", element.getCase(), -1);
    }
  }

  protected void composeRegulatedAuthorizationCaseComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationCaseComponent 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, "case", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "RegulatedAuthorizationCaseComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "type", element.getType(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "status", element.getStatus(), -1);
    }
    if (element.hasDate()) {
      composeType(t, "RegulatedAuthorizationCaseComponent", "date", element.getDate(), -1);
    }
    for (int i = 0; i < element.getApplication().size(); i++) {
      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorizationCaseComponent", "application", element.getApplication().get(i), i);
    }
  }

  protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson 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, "RelatedPerson", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1);
    }
    for (int i = 0; i < element.getRelationship().size(); i++) {
      composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship().get(i), i);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getTelecom().size(); i++) {
      composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i);
    }
    if (element.hasGenderElement()) {
      composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1);
    }
    if (element.hasBirthDateElement()) {
      composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1);
    }
    for (int i = 0; i < element.getAddress().size(); i++) {
      composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i);
    }
    for (int i = 0; i < element.getPhoto().size(); i++) {
      composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getCommunication().size(); i++) {
      composeRelatedPersonCommunicationComponent(t, "RelatedPerson", "communication", element.getCommunication().get(i), i);
    }
  }

  protected void composeRelatedPersonCommunicationComponent(Complex parent, String parentType, String name, RelatedPerson.RelatedPersonCommunicationComponent 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, "communication", name, element, index);
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "RelatedPersonCommunicationComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "RelatedPersonCommunicationComponent", "preferred", element.getPreferredElement(), -1);
    }
  }

  protected void composeRequestOrchestration(Complex parent, String parentType, String name, RequestOrchestration 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, "RequestOrchestration", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "RequestOrchestration", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "RequestOrchestration", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "RequestOrchestration", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "RequestOrchestration", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "RequestOrchestration", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "RequestOrchestration", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "RequestOrchestration", "status", element.getStatusElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "RequestOrchestration", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "RequestOrchestration", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "RequestOrchestration", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "RequestOrchestration", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "RequestOrchestration", "encounter", element.getEncounter(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "RequestOrchestration", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasAuthor()) {
      composeReference(t, "RequestOrchestration", "author", element.getAuthor(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "RequestOrchestration", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getGoal().size(); i++) {
      composeReference(t, "RequestOrchestration", "goal", element.getGoal().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "RequestOrchestration", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeRequestOrchestrationActionComponent(t, "RequestOrchestration", "action", element.getAction().get(i), i);
    }
  }

  protected void composeRequestOrchestrationActionComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionComponent 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.hasLinkIdElement()) {
      composeString(t, "RequestOrchestrationActionComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasPrefixElement()) {
      composeString(t, "RequestOrchestrationActionComponent", "prefix", element.getPrefixElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "RequestOrchestrationActionComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "RequestOrchestrationActionComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasTextEquivalentElement()) {
      composeMarkdown(t, "RequestOrchestrationActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "priority", element.getPriorityElement(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeCodeableConcept(t, "RequestOrchestrationActionComponent", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getDocumentation().size(); i++) {
      composeRelatedArtifact(t, "RequestOrchestrationActionComponent", "documentation", element.getDocumentation().get(i), i);
    }
    for (int i = 0; i < element.getGoal().size(); i++) {
      composeReference(t, "RequestOrchestrationActionComponent", "goal", element.getGoal().get(i), i);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeRequestOrchestrationActionConditionComponent(t, "RequestOrchestrationActionComponent", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composeRequestOrchestrationActionInputComponent(t, "RequestOrchestrationActionComponent", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getOutput().size(); i++) {
      composeRequestOrchestrationActionOutputComponent(t, "RequestOrchestrationActionComponent", "output", element.getOutput().get(i), i);
    }
    for (int i = 0; i < element.getRelatedAction().size(); i++) {
      composeRequestOrchestrationActionRelatedActionComponent(t, "RequestOrchestrationActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
    }
    if (element.hasTiming()) {
      composeType(t, "RequestOrchestrationActionComponent", "timing", element.getTiming(), -1);
    }
    if (element.hasLocation()) {
      composeCodeableReference(t, "RequestOrchestrationActionComponent", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeRequestOrchestrationActionParticipantComponent(t, "RequestOrchestrationActionComponent", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "RequestOrchestrationActionComponent", "type", element.getType(), -1);
    }
    if (element.hasGroupingBehaviorElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
    }
    if (element.hasSelectionBehaviorElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
    }
    if (element.hasRequiredBehaviorElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
    }
    if (element.hasPrecheckBehaviorElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
    }
    if (element.hasCardinalityBehaviorElement()) {
      composeEnum(t, "RequestOrchestrationActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
    }
    if (element.hasResource()) {
      composeReference(t, "RequestOrchestrationActionComponent", "resource", element.getResource(), -1);
    }
    if (element.hasDefinition()) {
      composeType(t, "RequestOrchestrationActionComponent", "definition", element.getDefinition(), -1);
    }
    if (element.hasTransformElement()) {
      composeCanonical(t, "RequestOrchestrationActionComponent", "transform", element.getTransformElement(), -1);
    }
    for (int i = 0; i < element.getDynamicValue().size(); i++) {
      composeRequestOrchestrationActionDynamicValueComponent(t, "RequestOrchestrationActionComponent", "dynamicValue", element.getDynamicValue().get(i), i);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeRequestOrchestrationActionComponent(t, "RequestOrchestrationActionComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeRequestOrchestrationActionConditionComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionConditionComponent 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, "condition", name, element, index);
    if (element.hasKindElement()) {
      composeEnum(t, "RequestOrchestrationActionConditionComponent", "kind", element.getKindElement(), -1);
    }
    if (element.hasExpression()) {
      composeExpression(t, "RequestOrchestrationActionConditionComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composeRequestOrchestrationActionInputComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionInputComponent 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, "input", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "RequestOrchestrationActionInputComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasRequirement()) {
      composeDataRequirement(t, "RequestOrchestrationActionInputComponent", "requirement", element.getRequirement(), -1);
    }
    if (element.hasRelatedDataElement()) {
      composeId(t, "RequestOrchestrationActionInputComponent", "relatedData", element.getRelatedDataElement(), -1);
    }
  }

  protected void composeRequestOrchestrationActionOutputComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionOutputComponent 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, "output", name, element, index);
    if (element.hasTitleElement()) {
      composeString(t, "RequestOrchestrationActionOutputComponent", "title", element.getTitleElement(), -1);
    }
    if (element.hasRequirement()) {
      composeDataRequirement(t, "RequestOrchestrationActionOutputComponent", "requirement", element.getRequirement(), -1);
    }
    if (element.hasRelatedDataElement()) {
      composeString(t, "RequestOrchestrationActionOutputComponent", "relatedData", element.getRelatedDataElement(), -1);
    }
  }

  protected void composeRequestOrchestrationActionRelatedActionComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionRelatedActionComponent 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, "relatedAction", name, element, index);
    if (element.hasTargetIdElement()) {
      composeId(t, "RequestOrchestrationActionRelatedActionComponent", "targetId", element.getTargetIdElement(), -1);
    }
    if (element.hasRelationshipElement()) {
      composeEnum(t, "RequestOrchestrationActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
    }
    if (element.hasEndRelationshipElement()) {
      composeEnum(t, "RequestOrchestrationActionRelatedActionComponent", "endRelationship", element.getEndRelationshipElement(), -1);
    }
    if (element.hasOffset()) {
      composeType(t, "RequestOrchestrationActionRelatedActionComponent", "offset", element.getOffset(), -1);
    }
  }

  protected void composeRequestOrchestrationActionParticipantComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionParticipantComponent 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, "RequestOrchestrationActionParticipantComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasTypeCanonicalElement()) {
      composeCanonical(t, "RequestOrchestrationActionParticipantComponent", "typeCanonical", element.getTypeCanonicalElement(), -1);
    }
    if (element.hasTypeReference()) {
      composeReference(t, "RequestOrchestrationActionParticipantComponent", "typeReference", element.getTypeReference(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "RequestOrchestrationActionParticipantComponent", "role", element.getRole(), -1);
    }
    if (element.hasFunction()) {
      composeCodeableConcept(t, "RequestOrchestrationActionParticipantComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeType(t, "RequestOrchestrationActionParticipantComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeRequestOrchestrationActionDynamicValueComponent(Complex parent, String parentType, String name, RequestOrchestration.RequestOrchestrationActionDynamicValueComponent 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, "RequestOrchestrationActionDynamicValueComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasExpression()) {
      composeExpression(t, "RequestOrchestrationActionDynamicValueComponent", "expression", element.getExpression(), -1);
    }
  }

  protected void composeRequirements(Complex parent, String parentType, String name, Requirements 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, "Requirements", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "Requirements", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Requirements", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "Requirements", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "Requirements", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "Requirements", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "Requirements", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Requirements", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "Requirements", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "Requirements", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "Requirements", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "Requirements", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Requirements", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "Requirements", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "Requirements", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "Requirements", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "Requirements", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "Requirements", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeCanonical(t, "Requirements", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    for (int i = 0; i < element.getReference().size(); i++) {
      composeUrl(t, "Requirements", "reference", element.getReference().get(i), i);
    }
    for (int i = 0; i < element.getActor().size(); i++) {
      composeCanonical(t, "Requirements", "actor", element.getActor().get(i), i);
    }
    for (int i = 0; i < element.getStatement().size(); i++) {
      composeRequirementsStatementComponent(t, "Requirements", "statement", element.getStatement().get(i), i);
    }
  }

  protected void composeRequirementsStatementComponent(Complex parent, String parentType, String name, Requirements.RequirementsStatementComponent 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, "statement", name, element, index);
    if (element.hasKeyElement()) {
      composeId(t, "RequirementsStatementComponent", "key", element.getKeyElement(), -1);
    }
    if (element.hasLabelElement()) {
      composeString(t, "RequirementsStatementComponent", "label", element.getLabelElement(), -1);
    }
    for (int i = 0; i < element.getConformance().size(); i++) {
      composeEnum(t, "RequirementsStatementComponent", "conformance", element.getConformance().get(i), i);
    }
    if (element.hasConditionalityElement()) {
      composeBoolean(t, "RequirementsStatementComponent", "conditionality", element.getConditionalityElement(), -1);
    }
    if (element.hasRequirementElement()) {
      composeMarkdown(t, "RequirementsStatementComponent", "requirement", element.getRequirementElement(), -1);
    }
    if (element.hasDerivedFromElement()) {
      composeString(t, "RequirementsStatementComponent", "derivedFrom", element.getDerivedFromElement(), -1);
    }
    if (element.hasParentElement()) {
      composeString(t, "RequirementsStatementComponent", "parent", element.getParentElement(), -1);
    }
    for (int i = 0; i < element.getSatisfiedBy().size(); i++) {
      composeUrl(t, "RequirementsStatementComponent", "satisfiedBy", element.getSatisfiedBy().get(i), i);
    }
    for (int i = 0; i < element.getReference().size(); i++) {
      composeUrl(t, "RequirementsStatementComponent", "reference", element.getReference().get(i), i);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "RequirementsStatementComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy 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, "ResearchStudy", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ResearchStudy", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ResearchStudy", "version", element.getVersionElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ResearchStudy", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getLabel().size(); i++) {
      composeResearchStudyLabelComponent(t, "ResearchStudy", "label", element.getLabel().get(i), i);
    }
    for (int i = 0; i < element.getProtocol().size(); i++) {
      composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ResearchStudy", "date", element.getDateElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1);
    }
    if (element.hasPrimaryPurposeType()) {
      composeCodeableConcept(t, "ResearchStudy", "primaryPurposeType", element.getPrimaryPurposeType(), -1);
    }
    if (element.hasPhase()) {
      composeCodeableConcept(t, "ResearchStudy", "phase", element.getPhase(), -1);
    }
    for (int i = 0; i < element.getStudyDesign().size(); i++) {
      composeCodeableConcept(t, "ResearchStudy", "studyDesign", element.getStudyDesign().get(i), i);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeCodeableReference(t, "ResearchStudy", "focus", element.getFocus().get(i), i);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeCodeableConcept(t, "ResearchStudy", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getKeyword().size(); i++) {
      composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i);
    }
    for (int i = 0; i < element.getRegion().size(); i++) {
      composeCodeableConcept(t, "ResearchStudy", "region", element.getRegion().get(i), i);
    }
    if (element.hasDescriptionSummaryElement()) {
      composeMarkdown(t, "ResearchStudy", "descriptionSummary", element.getDescriptionSummaryElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getSite().size(); i++) {
      composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "ResearchStudy", "classifier", element.getClassifier().get(i), i);
    }
    for (int i = 0; i < element.getAssociatedParty().size(); i++) {
      composeResearchStudyAssociatedPartyComponent(t, "ResearchStudy", "associatedParty", element.getAssociatedParty().get(i), i);
    }
    for (int i = 0; i < element.getProgressStatus().size(); i++) {
      composeResearchStudyProgressStatusComponent(t, "ResearchStudy", "progressStatus", element.getProgressStatus().get(i), i);
    }
    if (element.hasWhyStopped()) {
      composeCodeableConcept(t, "ResearchStudy", "whyStopped", element.getWhyStopped(), -1);
    }
    if (element.hasRecruitment()) {
      composeResearchStudyRecruitmentComponent(t, "ResearchStudy", "recruitment", element.getRecruitment(), -1);
    }
    for (int i = 0; i < element.getComparisonGroup().size(); i++) {
      composeResearchStudyComparisonGroupComponent(t, "ResearchStudy", "comparisonGroup", element.getComparisonGroup().get(i), i);
    }
    for (int i = 0; i < element.getObjective().size(); i++) {
      composeResearchStudyObjectiveComponent(t, "ResearchStudy", "objective", element.getObjective().get(i), i);
    }
    for (int i = 0; i < element.getOutcomeMeasure().size(); i++) {
      composeResearchStudyOutcomeMeasureComponent(t, "ResearchStudy", "outcomeMeasure", element.getOutcomeMeasure().get(i), i);
    }
    for (int i = 0; i < element.getResult().size(); i++) {
      composeReference(t, "ResearchStudy", "result", element.getResult().get(i), i);
    }
  }

  protected void composeResearchStudyLabelComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyLabelComponent 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, "label", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ResearchStudyLabelComponent", "type", element.getType(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "ResearchStudyLabelComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeResearchStudyAssociatedPartyComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyAssociatedPartyComponent 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, "associatedParty", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ResearchStudyAssociatedPartyComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasRole()) {
      composeCodeableConcept(t, "ResearchStudyAssociatedPartyComponent", "role", element.getRole(), -1);
    }
    for (int i = 0; i < element.getPeriod().size(); i++) {
      composePeriod(t, "ResearchStudyAssociatedPartyComponent", "period", element.getPeriod().get(i), i);
    }
    for (int i = 0; i < element.getClassifier().size(); i++) {
      composeCodeableConcept(t, "ResearchStudyAssociatedPartyComponent", "classifier", element.getClassifier().get(i), i);
    }
    if (element.hasParty()) {
      composeReference(t, "ResearchStudyAssociatedPartyComponent", "party", element.getParty(), -1);
    }
  }

  protected void composeResearchStudyProgressStatusComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyProgressStatusComponent 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, "progressStatus", name, element, index);
    if (element.hasState()) {
      composeCodeableConcept(t, "ResearchStudyProgressStatusComponent", "state", element.getState(), -1);
    }
    if (element.hasActualElement()) {
      composeBoolean(t, "ResearchStudyProgressStatusComponent", "actual", element.getActualElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ResearchStudyProgressStatusComponent", "period", element.getPeriod(), -1);
    }
  }

  protected void composeResearchStudyRecruitmentComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyRecruitmentComponent 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, "recruitment", name, element, index);
    if (element.hasTargetNumberElement()) {
      composeUnsignedInt(t, "ResearchStudyRecruitmentComponent", "targetNumber", element.getTargetNumberElement(), -1);
    }
    if (element.hasActualNumberElement()) {
      composeUnsignedInt(t, "ResearchStudyRecruitmentComponent", "actualNumber", element.getActualNumberElement(), -1);
    }
    if (element.hasEligibility()) {
      composeReference(t, "ResearchStudyRecruitmentComponent", "eligibility", element.getEligibility(), -1);
    }
    if (element.hasActualGroup()) {
      composeReference(t, "ResearchStudyRecruitmentComponent", "actualGroup", element.getActualGroup(), -1);
    }
  }

  protected void composeResearchStudyComparisonGroupComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyComparisonGroupComponent 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, "comparisonGroup", name, element, index);
    if (element.hasLinkIdElement()) {
      composeId(t, "ResearchStudyComparisonGroupComponent", "linkId", element.getLinkIdElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ResearchStudyComparisonGroupComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ResearchStudyComparisonGroupComponent", "type", element.getType(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ResearchStudyComparisonGroupComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getIntendedExposure().size(); i++) {
      composeReference(t, "ResearchStudyComparisonGroupComponent", "intendedExposure", element.getIntendedExposure().get(i), i);
    }
    if (element.hasObservedGroup()) {
      composeReference(t, "ResearchStudyComparisonGroupComponent", "observedGroup", element.getObservedGroup(), -1);
    }
  }

  protected void composeResearchStudyObjectiveComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyObjectiveComponent 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, "objective", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ResearchStudyObjectiveComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "ResearchStudyObjectiveComponent", "type", element.getType(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ResearchStudyObjectiveComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeResearchStudyOutcomeMeasureComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyOutcomeMeasureComponent 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, "outcomeMeasure", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ResearchStudyOutcomeMeasureComponent", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "ResearchStudyOutcomeMeasureComponent", "type", element.getType().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ResearchStudyOutcomeMeasureComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasReference()) {
      composeReference(t, "ResearchStudyOutcomeMeasureComponent", "reference", element.getReference(), -1);
    }
  }

  protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject 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, "ResearchSubject", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getProgress().size(); i++) {
      composeResearchSubjectProgressComponent(t, "ResearchSubject", "progress", element.getProgress().get(i), i);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1);
    }
    if (element.hasStudy()) {
      composeReference(t, "ResearchSubject", "study", element.getStudy(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "ResearchSubject", "subject", element.getSubject(), -1);
    }
    if (element.hasAssignedComparisonGroupElement()) {
      composeId(t, "ResearchSubject", "assignedComparisonGroup", element.getAssignedComparisonGroupElement(), -1);
    }
    if (element.hasActualComparisonGroupElement()) {
      composeId(t, "ResearchSubject", "actualComparisonGroup", element.getActualComparisonGroupElement(), -1);
    }
    for (int i = 0; i < element.getConsent().size(); i++) {
      composeReference(t, "ResearchSubject", "consent", element.getConsent().get(i), i);
    }
  }

  protected void composeResearchSubjectProgressComponent(Complex parent, String parentType, String name, ResearchSubject.ResearchSubjectProgressComponent 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, "progress", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "type", element.getType(), -1);
    }
    if (element.hasSubjectState()) {
      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "subjectState", element.getSubjectState(), -1);
    }
    if (element.hasMilestone()) {
      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "milestone", element.getMilestone(), -1);
    }
    if (element.hasReason()) {
      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "reason", element.getReason(), -1);
    }
    if (element.hasStartDateElement()) {
      composeDateTime(t, "ResearchSubjectProgressComponent", "startDate", element.getStartDateElement(), -1);
    }
    if (element.hasEndDateElement()) {
      composeDateTime(t, "ResearchSubjectProgressComponent", "endDate", element.getEndDateElement(), -1);
    }
  }

  protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment 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, "RiskAssessment", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasBasedOn()) {
      composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1);
    }
    if (element.hasParent()) {
      composeReference(t, "RiskAssessment", "parent", element.getParent(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasCondition()) {
      composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1);
    }
    if (element.hasPerformer()) {
      composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "RiskAssessment", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getBasis().size(); i++) {
      composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i);
    }
    for (int i = 0; i < element.getPrediction().size(); i++) {
      composeRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i);
    }
    if (element.hasMitigationElement()) {
      composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "RiskAssessment", "note", element.getNote().get(i), i);
    }
  }

  protected void composeRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent 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, "prediction", name, element, index);
    if (element.hasOutcome()) {
      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "outcome", element.getOutcome(), -1);
    }
    if (element.hasProbability()) {
      composeType(t, "RiskAssessmentPredictionComponent", "probability", element.getProbability(), -1);
    }
    if (element.hasQualitativeRisk()) {
      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "qualitativeRisk", element.getQualitativeRisk(), -1);
    }
    if (element.hasRelativeRiskElement()) {
      composeDecimal(t, "RiskAssessmentPredictionComponent", "relativeRisk", element.getRelativeRiskElement(), -1);
    }
    if (element.hasWhen()) {
      composeType(t, "RiskAssessmentPredictionComponent", "when", element.getWhen(), -1);
    }
    if (element.hasRationaleElement()) {
      composeString(t, "RiskAssessmentPredictionComponent", "rationale", element.getRationaleElement(), -1);
    }
  }

  protected void composeSchedule(Complex parent, String parentType, String name, Schedule 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, "Schedule", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasActiveElement()) {
      composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1);
    }
    for (int i = 0; i < element.getServiceCategory().size(); i++) {
      composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory().get(i), i);
    }
    for (int i = 0; i < element.getServiceType().size(); i++) {
      composeCodeableReference(t, "Schedule", "serviceType", element.getServiceType().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Schedule", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getActor().size(); i++) {
      composeReference(t, "Schedule", "actor", element.getActor().get(i), i);
    }
    if (element.hasPlanningHorizon()) {
      composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1);
    }
    if (element.hasCommentElement()) {
      composeMarkdown(t, "Schedule", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter 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, "SearchParameter", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "SearchParameter", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "SearchParameter", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "SearchParameter", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SearchParameter", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "SearchParameter", "title", element.getTitleElement(), -1);
    }
    if (element.hasDerivedFromElement()) {
      composeCanonical(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "SearchParameter", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "SearchParameter", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1);
    }
    for (int i = 0; i < element.getBase().size(); i++) {
      composeEnum(t, "SearchParameter", "base", element.getBase().get(i), i);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasProcessingModeElement()) {
      composeEnum(t, "SearchParameter", "processingMode", element.getProcessingModeElement(), -1);
    }
    if (element.hasConstraintElement()) {
      composeString(t, "SearchParameter", "constraint", element.getConstraintElement(), -1);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeEnum(t, "SearchParameter", "target", element.getTarget().get(i), i);
    }
    if (element.hasMultipleOrElement()) {
      composeBoolean(t, "SearchParameter", "multipleOr", element.getMultipleOrElement(), -1);
    }
    if (element.hasMultipleAndElement()) {
      composeBoolean(t, "SearchParameter", "multipleAnd", element.getMultipleAndElement(), -1);
    }
    for (int i = 0; i < element.getComparator().size(); i++) {
      composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i);
    }
    for (int i = 0; i < element.getChain().size(); i++) {
      composeString(t, "SearchParameter", "chain", element.getChain().get(i), i);
    }
    for (int i = 0; i < element.getComponent().size(); i++) {
      composeSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i);
    }
  }

  protected void composeSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent 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, "component", name, element, index);
    if (element.hasDefinitionElement()) {
      composeCanonical(t, "SearchParameterComponentComponent", "definition", element.getDefinitionElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "SearchParameterComponentComponent", "expression", element.getExpressionElement(), -1);
    }
  }

  protected void composeServiceRequest(Complex parent, String parentType, String name, ServiceRequest 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, "ServiceRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ServiceRequest", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
      composeCanonical(t, "ServiceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
    }
    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
      composeUri(t, "ServiceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "ServiceRequest", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getReplaces().size(); i++) {
      composeReference(t, "ServiceRequest", "replaces", element.getReplaces().get(i), i);
    }
    if (element.hasRequisition()) {
      composeIdentifier(t, "ServiceRequest", "requisition", element.getRequisition(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ServiceRequest", "status", element.getStatusElement(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "ServiceRequest", "intent", element.getIntentElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "ServiceRequest", "category", element.getCategory().get(i), i);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "ServiceRequest", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "ServiceRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableReference(t, "ServiceRequest", "code", element.getCode(), -1);
    }
    for (int i = 0; i < element.getOrderDetail().size(); i++) {
      composeServiceRequestOrderDetailComponent(t, "ServiceRequest", "orderDetail", element.getOrderDetail().get(i), i);
    }
    if (element.hasQuantity()) {
      composeType(t, "ServiceRequest", "quantity", element.getQuantity(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "ServiceRequest", "subject", element.getSubject(), -1);
    }
    for (int i = 0; i < element.getFocus().size(); i++) {
      composeReference(t, "ServiceRequest", "focus", element.getFocus().get(i), i);
    }
    if (element.hasEncounter()) {
      composeReference(t, "ServiceRequest", "encounter", element.getEncounter(), -1);
    }
    if (element.hasOccurrence()) {
      composeType(t, "ServiceRequest", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasAsNeeded()) {
      composeType(t, "ServiceRequest", "asNeeded", element.getAsNeeded(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "ServiceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "ServiceRequest", "requester", element.getRequester(), -1);
    }
    if (element.hasPerformerType()) {
      composeCodeableConcept(t, "ServiceRequest", "performerType", element.getPerformerType(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeReference(t, "ServiceRequest", "performer", element.getPerformer().get(i), i);
    }
    for (int i = 0; i < element.getLocation().size(); i++) {
      composeCodeableReference(t, "ServiceRequest", "location", element.getLocation().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "ServiceRequest", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeReference(t, "ServiceRequest", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
      composeCodeableReference(t, "ServiceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
    }
    for (int i = 0; i < element.getSpecimen().size(); i++) {
      composeReference(t, "ServiceRequest", "specimen", element.getSpecimen().get(i), i);
    }
    for (int i = 0; i < element.getBodySite().size(); i++) {
      composeCodeableConcept(t, "ServiceRequest", "bodySite", element.getBodySite().get(i), i);
    }
    if (element.hasBodyStructure()) {
      composeReference(t, "ServiceRequest", "bodyStructure", element.getBodyStructure(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "ServiceRequest", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getPatientInstruction().size(); i++) {
      composeServiceRequestPatientInstructionComponent(t, "ServiceRequest", "patientInstruction", element.getPatientInstruction().get(i), i);
    }
    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
      composeReference(t, "ServiceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
    }
  }

  protected void composeServiceRequestOrderDetailComponent(Complex parent, String parentType, String name, ServiceRequest.ServiceRequestOrderDetailComponent 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, "orderDetail", name, element, index);
    if (element.hasParameterFocus()) {
      composeCodeableReference(t, "ServiceRequestOrderDetailComponent", "parameterFocus", element.getParameterFocus(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeServiceRequestOrderDetailParameterComponent(t, "ServiceRequestOrderDetailComponent", "parameter", element.getParameter().get(i), i);
    }
  }

  protected void composeServiceRequestOrderDetailParameterComponent(Complex parent, String parentType, String name, ServiceRequest.ServiceRequestOrderDetailParameterComponent 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, "parameter", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "ServiceRequestOrderDetailParameterComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ServiceRequestOrderDetailParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeServiceRequestPatientInstructionComponent(Complex parent, String parentType, String name, ServiceRequest.ServiceRequestPatientInstructionComponent 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, "patientInstruction", name, element, index);
    if (element.hasInstruction()) {
      composeType(t, "ServiceRequestPatientInstructionComponent", "instruction", element.getInstruction(), -1);
    }
  }

  protected void composeSlot(Complex parent, String parentType, String name, Slot 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, "Slot", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getServiceCategory().size(); i++) {
      composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory().get(i), i);
    }
    for (int i = 0; i < element.getServiceType().size(); i++) {
      composeCodeableReference(t, "Slot", "serviceType", element.getServiceType().get(i), i);
    }
    for (int i = 0; i < element.getSpecialty().size(); i++) {
      composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i);
    }
    for (int i = 0; i < element.getAppointmentType().size(); i++) {
      composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType().get(i), i);
    }
    if (element.hasSchedule()) {
      composeReference(t, "Slot", "schedule", element.getSchedule(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Slot", "status", element.getStatusElement(), -1);
    }
    if (element.hasStartElement()) {
      composeInstant(t, "Slot", "start", element.getStartElement(), -1);
    }
    if (element.hasEndElement()) {
      composeInstant(t, "Slot", "end", element.getEndElement(), -1);
    }
    if (element.hasOverbookedElement()) {
      composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeString(t, "Slot", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeSpecimen(Complex parent, String parentType, String name, Specimen 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, "Specimen", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasAccessionIdentifier()) {
      composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Specimen", "status", element.getStatusElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "Specimen", "type", element.getType(), -1);
    }
    if (element.hasSubject()) {
      composeReference(t, "Specimen", "subject", element.getSubject(), -1);
    }
    if (element.hasReceivedTimeElement()) {
      composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1);
    }
    for (int i = 0; i < element.getParent().size(); i++) {
      composeReference(t, "Specimen", "parent", element.getParent().get(i), i);
    }
    for (int i = 0; i < element.getRequest().size(); i++) {
      composeReference(t, "Specimen", "request", element.getRequest().get(i), i);
    }
    if (element.hasCombinedElement()) {
      composeEnum(t, "Specimen", "combined", element.getCombinedElement(), -1);
    }
    for (int i = 0; i < element.getRole().size(); i++) {
      composeCodeableConcept(t, "Specimen", "role", element.getRole().get(i), i);
    }
    for (int i = 0; i < element.getFeature().size(); i++) {
      composeSpecimenFeatureComponent(t, "Specimen", "feature", element.getFeature().get(i), i);
    }
    if (element.hasCollection()) {
      composeSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1);
    }
    for (int i = 0; i < element.getProcessing().size(); i++) {
      composeSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i);
    }
    for (int i = 0; i < element.getContainer().size(); i++) {
      composeSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i);
    }
    for (int i = 0; i < element.getCondition().size(); i++) {
      composeCodeableConcept(t, "Specimen", "condition", element.getCondition().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i);
    }
  }

  protected void composeSpecimenFeatureComponent(Complex parent, String parentType, String name, Specimen.SpecimenFeatureComponent 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, "feature", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SpecimenFeatureComponent", "type", element.getType(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "SpecimenFeatureComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent 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, "SpecimenCollectionComponent", "collector", element.getCollector(), -1);
    }
    if (element.hasCollected()) {
      composeType(t, "SpecimenCollectionComponent", "collected", element.getCollected(), -1);
    }
    if (element.hasDuration()) {
      composeDuration(t, "SpecimenCollectionComponent", "duration", element.getDuration(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "SpecimenCollectionComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "SpecimenCollectionComponent", "method", element.getMethod(), -1);
    }
    if (element.hasDevice()) {
      composeCodeableReference(t, "SpecimenCollectionComponent", "device", element.getDevice(), -1);
    }
    if (element.hasProcedure()) {
      composeReference(t, "SpecimenCollectionComponent", "procedure", element.getProcedure(), -1);
    }
    if (element.hasBodySite()) {
      composeCodeableReference(t, "SpecimenCollectionComponent", "bodySite", element.getBodySite(), -1);
    }
    if (element.hasFastingStatus()) {
      composeType(t, "SpecimenCollectionComponent", "fastingStatus", element.getFastingStatus(), -1);
    }
  }

  protected void composeSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent 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, "processing", name, element, index);
    if (element.hasDescriptionElement()) {
      composeString(t, "SpecimenProcessingComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasMethod()) {
      composeCodeableConcept(t, "SpecimenProcessingComponent", "method", element.getMethod(), -1);
    }
    for (int i = 0; i < element.getAdditive().size(); i++) {
      composeReference(t, "SpecimenProcessingComponent", "additive", element.getAdditive().get(i), i);
    }
    if (element.hasTime()) {
      composeType(t, "SpecimenProcessingComponent", "time", element.getTime(), -1);
    }
  }

  protected void composeSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent 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, "container", name, element, index);
    if (element.hasDevice()) {
      composeReference(t, "SpecimenContainerComponent", "device", element.getDevice(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "SpecimenContainerComponent", "location", element.getLocation(), -1);
    }
    if (element.hasSpecimenQuantity()) {
      composeQuantity(t, "SpecimenContainerComponent", "specimenQuantity", element.getSpecimenQuantity(), -1);
    }
  }

  protected void composeSpecimenDefinition(Complex parent, String parentType, String name, SpecimenDefinition 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, "SpecimenDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "SpecimenDefinition", "url", element.getUrlElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "SpecimenDefinition", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "SpecimenDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "SpecimenDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SpecimenDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "SpecimenDefinition", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) {
      composeCanonical(t, "SpecimenDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i);
    }
    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
      composeUri(t, "SpecimenDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "SpecimenDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "SpecimenDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasSubject()) {
      composeType(t, "SpecimenDefinition", "subject", element.getSubject(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "SpecimenDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "SpecimenDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "SpecimenDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SpecimenDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "SpecimenDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "SpecimenDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "SpecimenDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "SpecimenDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "SpecimenDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "SpecimenDefinition", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "SpecimenDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "SpecimenDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    if (element.hasTypeCollected()) {
      composeCodeableConcept(t, "SpecimenDefinition", "typeCollected", element.getTypeCollected(), -1);
    }
    for (int i = 0; i < element.getPatientPreparation().size(); i++) {
      composeCodeableConcept(t, "SpecimenDefinition", "patientPreparation", element.getPatientPreparation().get(i), i);
    }
    if (element.hasTimeAspectElement()) {
      composeString(t, "SpecimenDefinition", "timeAspect", element.getTimeAspectElement(), -1);
    }
    for (int i = 0; i < element.getCollection().size(); i++) {
      composeCodeableConcept(t, "SpecimenDefinition", "collection", element.getCollection().get(i), i);
    }
    for (int i = 0; i < element.getTypeTested().size(); i++) {
      composeSpecimenDefinitionTypeTestedComponent(t, "SpecimenDefinition", "typeTested", element.getTypeTested().get(i), i);
    }
  }

  protected void composeSpecimenDefinitionTypeTestedComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedComponent 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, "typeTested", name, element, index);
    if (element.hasIsDerivedElement()) {
      composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "isDerived", element.getIsDerivedElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "type", element.getType(), -1);
    }
    if (element.hasPreferenceElement()) {
      composeEnum(t, "SpecimenDefinitionTypeTestedComponent", "preference", element.getPreferenceElement(), -1);
    }
    if (element.hasContainer()) {
      composeSpecimenDefinitionTypeTestedContainerComponent(t, "SpecimenDefinitionTypeTestedComponent", "container", element.getContainer(), -1);
    }
    if (element.hasRequirementElement()) {
      composeMarkdown(t, "SpecimenDefinitionTypeTestedComponent", "requirement", element.getRequirementElement(), -1);
    }
    if (element.hasRetentionTime()) {
      composeDuration(t, "SpecimenDefinitionTypeTestedComponent", "retentionTime", element.getRetentionTime(), -1);
    }
    if (element.hasSingleUseElement()) {
      composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "singleUse", element.getSingleUseElement(), -1);
    }
    for (int i = 0; i < element.getRejectionCriterion().size(); i++) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "rejectionCriterion", element.getRejectionCriterion().get(i), i);
    }
    for (int i = 0; i < element.getHandling().size(); i++) {
      composeSpecimenDefinitionTypeTestedHandlingComponent(t, "SpecimenDefinitionTypeTestedComponent", "handling", element.getHandling().get(i), i);
    }
    for (int i = 0; i < element.getTestingDestination().size(); i++) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "testingDestination", element.getTestingDestination().get(i), i);
    }
  }

  protected void composeSpecimenDefinitionTypeTestedContainerComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerComponent 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, "container", name, element, index);
    if (element.hasMaterial()) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "material", element.getMaterial(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "type", element.getType(), -1);
    }
    if (element.hasCap()) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "cap", element.getCap(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SpecimenDefinitionTypeTestedContainerComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasCapacity()) {
      composeQuantity(t, "SpecimenDefinitionTypeTestedContainerComponent", "capacity", element.getCapacity(), -1);
    }
    if (element.hasMinimumVolume()) {
      composeType(t, "SpecimenDefinitionTypeTestedContainerComponent", "minimumVolume", element.getMinimumVolume(), -1);
    }
    for (int i = 0; i < element.getAdditive().size(); i++) {
      composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(t, "SpecimenDefinitionTypeTestedContainerComponent", "additive", element.getAdditive().get(i), i);
    }
    if (element.hasPreparationElement()) {
      composeMarkdown(t, "SpecimenDefinitionTypeTestedContainerComponent", "preparation", element.getPreparationElement(), -1);
    }
  }

  protected void composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerAdditiveComponent 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, "additive", name, element, index);
    if (element.hasAdditive()) {
      composeType(t, "SpecimenDefinitionTypeTestedContainerAdditiveComponent", "additive", element.getAdditive(), -1);
    }
  }

  protected void composeSpecimenDefinitionTypeTestedHandlingComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedHandlingComponent 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, "handling", name, element, index);
    if (element.hasTemperatureQualifier()) {
      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureQualifier", element.getTemperatureQualifier(), -1);
    }
    if (element.hasTemperatureRange()) {
      composeRange(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureRange", element.getTemperatureRange(), -1);
    }
    if (element.hasMaxDuration()) {
      composeDuration(t, "SpecimenDefinitionTypeTestedHandlingComponent", "maxDuration", element.getMaxDuration(), -1);
    }
    if (element.hasInstructionElement()) {
      composeMarkdown(t, "SpecimenDefinitionTypeTestedHandlingComponent", "instruction", element.getInstructionElement(), -1);
    }
  }

  protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition 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, "StructureDefinition", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "StructureDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "StructureDefinition", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "StructureDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getKeyword().size(); i++) {
      composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i);
    }
    if (element.hasFhirVersionElement()) {
      composeEnum(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1);
    }
    for (int i = 0; i < element.getMapping().size(); i++) {
      composeStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1);
    }
    if (element.hasAbstractElement()) {
      composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1);
    }
    for (int i = 0; i < element.getContext().size(); i++) {
      composeStructureDefinitionContextComponent(t, "StructureDefinition", "context", element.getContext().get(i), i);
    }
    for (int i = 0; i < element.getContextInvariant().size(); i++) {
      composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i);
    }
    if (element.hasTypeElement()) {
      composeUri(t, "StructureDefinition", "type", element.getTypeElement(), -1);
    }
    if (element.hasBaseDefinitionElement()) {
      composeCanonical(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1);
    }
    if (element.hasDerivationElement()) {
      composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1);
    }
    if (element.hasSnapshot()) {
      composeStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1);
    }
    if (element.hasDifferential()) {
      composeStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1);
    }
  }

  protected void composeStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent 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, "mapping", name, element, index);
    if (element.hasIdentityElement()) {
      composeId(t, "StructureDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "StructureDefinitionMappingComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "StructureDefinitionMappingComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasCommentElement()) {
      composeString(t, "StructureDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
    }
  }

  protected void composeStructureDefinitionContextComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContextComponent 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.hasTypeElement()) {
      composeEnum(t, "StructureDefinitionContextComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "StructureDefinitionContextComponent", "expression", element.getExpressionElement(), -1);
    }
  }

  protected void composeStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent 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, "snapshot", name, element, index);
    for (int i = 0; i < element.getElement().size(); i++) {
      composeElementDefinition(t, "StructureDefinitionSnapshotComponent", "element", element.getElement().get(i), i);
    }
  }

  protected void composeStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent 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, "differential", name, element, index);
    for (int i = 0; i < element.getElement().size(); i++) {
      composeElementDefinition(t, "StructureDefinitionDifferentialComponent", "element", element.getElement().get(i), i);
    }
  }

  protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap 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, "StructureMap", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "StructureMap", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "StructureMap", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "StructureMap", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "StructureMap", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "StructureMap", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "StructureMap", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getStructure().size(); i++) {
      composeStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i);
    }
    for (int i = 0; i < element.getImport().size(); i++) {
      composeCanonical(t, "StructureMap", "import", element.getImport().get(i), i);
    }
    for (int i = 0; i < element.getConst().size(); i++) {
      composeStructureMapConstComponent(t, "StructureMap", "const", element.getConst().get(i), i);
    }
    for (int i = 0; i < element.getGroup().size(); i++) {
      composeStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i);
    }
  }

  protected void composeStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent 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, "structure", name, element, index);
    if (element.hasUrlElement()) {
      composeCanonical(t, "StructureMapStructureComponent", "url", element.getUrlElement(), -1);
    }
    if (element.hasModeElement()) {
      composeEnum(t, "StructureMapStructureComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasAliasElement()) {
      composeString(t, "StructureMapStructureComponent", "alias", element.getAliasElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "StructureMapStructureComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeStructureMapConstComponent(Complex parent, String parentType, String name, StructureMap.StructureMapConstComponent 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, "const", name, element, index);
    if (element.hasNameElement()) {
      composeId(t, "StructureMapConstComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "StructureMapConstComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent 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.hasNameElement()) {
      composeId(t, "StructureMapGroupComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasExtendsElement()) {
      composeId(t, "StructureMapGroupComponent", "extends", element.getExtendsElement(), -1);
    }
    if (element.hasTypeModeElement()) {
      composeEnum(t, "StructureMapGroupComponent", "typeMode", element.getTypeModeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "StructureMapGroupComponent", "documentation", element.getDocumentationElement(), -1);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composeStructureMapGroupInputComponent(t, "StructureMapGroupComponent", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getRule().size(); i++) {
      composeStructureMapGroupRuleComponent(t, "StructureMapGroupComponent", "rule", element.getRule().get(i), i);
    }
  }

  protected void composeStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent 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, "input", name, element, index);
    if (element.hasNameElement()) {
      composeId(t, "StructureMapGroupInputComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeString(t, "StructureMapGroupInputComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasModeElement()) {
      composeEnum(t, "StructureMapGroupInputComponent", "mode", element.getModeElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "StructureMapGroupInputComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent 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.hasNameElement()) {
      composeId(t, "StructureMapGroupRuleComponent", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeStructureMapGroupRuleSourceComponent(t, "StructureMapGroupRuleComponent", "source", element.getSource().get(i), i);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeStructureMapGroupRuleTargetComponent(t, "StructureMapGroupRuleComponent", "target", element.getTarget().get(i), i);
    }
    for (int i = 0; i < element.getRule().size(); i++) {
      composeStructureMapGroupRuleComponent(t, "StructureMapGroupRuleComponent", "rule", element.getRule().get(i), i);
    }
    for (int i = 0; i < element.getDependent().size(); i++) {
      composeStructureMapGroupRuleDependentComponent(t, "StructureMapGroupRuleComponent", "dependent", element.getDependent().get(i), i);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "StructureMapGroupRuleComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent 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.hasContextElement()) {
      composeId(t, "StructureMapGroupRuleSourceComponent", "context", element.getContextElement(), -1);
    }
    if (element.hasMinElement()) {
      composeInteger(t, "StructureMapGroupRuleSourceComponent", "min", element.getMinElement(), -1);
    }
    if (element.hasMaxElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "max", element.getMaxElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasDefaultValueElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "defaultValue", element.getDefaultValueElement(), -1);
    }
    if (element.hasElementElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "element", element.getElementElement(), -1);
    }
    if (element.hasListModeElement()) {
      composeEnum(t, "StructureMapGroupRuleSourceComponent", "listMode", element.getListModeElement(), -1);
    }
    if (element.hasVariableElement()) {
      composeId(t, "StructureMapGroupRuleSourceComponent", "variable", element.getVariableElement(), -1);
    }
    if (element.hasConditionElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "condition", element.getConditionElement(), -1);
    }
    if (element.hasCheckElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "check", element.getCheckElement(), -1);
    }
    if (element.hasLogMessageElement()) {
      composeString(t, "StructureMapGroupRuleSourceComponent", "logMessage", element.getLogMessageElement(), -1);
    }
  }

  protected void composeStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent 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.hasContextElement()) {
      composeString(t, "StructureMapGroupRuleTargetComponent", "context", element.getContextElement(), -1);
    }
    if (element.hasElementElement()) {
      composeString(t, "StructureMapGroupRuleTargetComponent", "element", element.getElementElement(), -1);
    }
    if (element.hasVariableElement()) {
      composeId(t, "StructureMapGroupRuleTargetComponent", "variable", element.getVariableElement(), -1);
    }
    for (int i = 0; i < element.getListMode().size(); i++) {
      composeEnum(t, "StructureMapGroupRuleTargetComponent", "listMode", element.getListMode().get(i), i);
    }
    if (element.hasListRuleIdElement()) {
      composeId(t, "StructureMapGroupRuleTargetComponent", "listRuleId", element.getListRuleIdElement(), -1);
    }
    if (element.hasTransformElement()) {
      composeEnum(t, "StructureMapGroupRuleTargetComponent", "transform", element.getTransformElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeStructureMapGroupRuleTargetParameterComponent(t, "StructureMapGroupRuleTargetComponent", "parameter", element.getParameter().get(i), i);
    }
  }

  protected void composeStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent 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, "parameter", name, element, index);
    if (element.hasValue()) {
      composeType(t, "StructureMapGroupRuleTargetParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent 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, "dependent", name, element, index);
    if (element.hasNameElement()) {
      composeId(t, "StructureMapGroupRuleDependentComponent", "name", element.getNameElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeStructureMapGroupRuleTargetParameterComponent(t, "StructureMapGroupRuleDependentComponent", "parameter", element.getParameter().get(i), i);
    }
  }

  protected void composeSubscription(Complex parent, String parentType, String name, Subscription 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, "Subscription", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Subscription", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasNameElement()) {
      composeString(t, "Subscription", "name", element.getNameElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Subscription", "status", element.getStatusElement(), -1);
    }
    if (element.hasTopicElement()) {
      composeCanonical(t, "Subscription", "topic", element.getTopicElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i);
    }
    if (element.hasEndElement()) {
      composeInstant(t, "Subscription", "end", element.getEndElement(), -1);
    }
    if (element.hasManagingEntity()) {
      composeReference(t, "Subscription", "managingEntity", element.getManagingEntity(), -1);
    }
    if (element.hasReasonElement()) {
      composeString(t, "Subscription", "reason", element.getReasonElement(), -1);
    }
    for (int i = 0; i < element.getFilterBy().size(); i++) {
      composeSubscriptionFilterByComponent(t, "Subscription", "filterBy", element.getFilterBy().get(i), i);
    }
    if (element.hasChannelType()) {
      composeCoding(t, "Subscription", "channelType", element.getChannelType(), -1);
    }
    if (element.hasEndpointElement()) {
      composeUrl(t, "Subscription", "endpoint", element.getEndpointElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeSubscriptionParameterComponent(t, "Subscription", "parameter", element.getParameter().get(i), i);
    }
    if (element.hasHeartbeatPeriodElement()) {
      composeUnsignedInt(t, "Subscription", "heartbeatPeriod", element.getHeartbeatPeriodElement(), -1);
    }
    if (element.hasTimeoutElement()) {
      composeUnsignedInt(t, "Subscription", "timeout", element.getTimeoutElement(), -1);
    }
    if (element.hasContentTypeElement()) {
      composeCode(t, "Subscription", "contentType", element.getContentTypeElement(), -1);
    }
    if (element.hasContentElement()) {
      composeEnum(t, "Subscription", "content", element.getContentElement(), -1);
    }
    if (element.hasMaxCountElement()) {
      composePositiveInt(t, "Subscription", "maxCount", element.getMaxCountElement(), -1);
    }
  }

  protected void composeSubscriptionFilterByComponent(Complex parent, String parentType, String name, Subscription.SubscriptionFilterByComponent 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, "filterBy", name, element, index);
    if (element.hasResourceTypeElement()) {
      composeUri(t, "SubscriptionFilterByComponent", "resourceType", element.getResourceTypeElement(), -1);
    }
    if (element.hasFilterParameterElement()) {
      composeString(t, "SubscriptionFilterByComponent", "filterParameter", element.getFilterParameterElement(), -1);
    }
    if (element.hasComparatorElement()) {
      composeEnum(t, "SubscriptionFilterByComponent", "comparator", element.getComparatorElement(), -1);
    }
    if (element.hasModifierElement()) {
      composeEnum(t, "SubscriptionFilterByComponent", "modifier", element.getModifierElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "SubscriptionFilterByComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeSubscriptionParameterComponent(Complex parent, String parentType, String name, Subscription.SubscriptionParameterComponent 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, "parameter", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "SubscriptionParameterComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "SubscriptionParameterComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeSubscriptionStatus(Complex parent, String parentType, String name, SubscriptionStatus 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, "SubscriptionStatus", name, element, index);
    if (element.hasStatusElement()) {
      composeEnum(t, "SubscriptionStatus", "status", element.getStatusElement(), -1);
    }
    if (element.hasTypeElement()) {
      composeEnum(t, "SubscriptionStatus", "type", element.getTypeElement(), -1);
    }
    if (element.hasEventsSinceSubscriptionStartElement()) {
      composeInteger64(t, "SubscriptionStatus", "eventsSinceSubscriptionStart", element.getEventsSinceSubscriptionStartElement(), -1);
    }
    for (int i = 0; i < element.getNotificationEvent().size(); i++) {
      composeSubscriptionStatusNotificationEventComponent(t, "SubscriptionStatus", "notificationEvent", element.getNotificationEvent().get(i), i);
    }
    if (element.hasSubscription()) {
      composeReference(t, "SubscriptionStatus", "subscription", element.getSubscription(), -1);
    }
    if (element.hasTopicElement()) {
      composeCanonical(t, "SubscriptionStatus", "topic", element.getTopicElement(), -1);
    }
    for (int i = 0; i < element.getError().size(); i++) {
      composeCodeableConcept(t, "SubscriptionStatus", "error", element.getError().get(i), i);
    }
  }

  protected void composeSubscriptionStatusNotificationEventComponent(Complex parent, String parentType, String name, SubscriptionStatus.SubscriptionStatusNotificationEventComponent 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, "notificationEvent", name, element, index);
    if (element.hasEventNumberElement()) {
      composeInteger64(t, "SubscriptionStatusNotificationEventComponent", "eventNumber", element.getEventNumberElement(), -1);
    }
    if (element.hasTimestampElement()) {
      composeInstant(t, "SubscriptionStatusNotificationEventComponent", "timestamp", element.getTimestampElement(), -1);
    }
    if (element.hasFocus()) {
      composeReference(t, "SubscriptionStatusNotificationEventComponent", "focus", element.getFocus(), -1);
    }
    for (int i = 0; i < element.getAdditionalContext().size(); i++) {
      composeReference(t, "SubscriptionStatusNotificationEventComponent", "additionalContext", element.getAdditionalContext().get(i), i);
    }
  }

  protected void composeSubscriptionTopic(Complex parent, String parentType, String name, SubscriptionTopic 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, "SubscriptionTopic", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "SubscriptionTopic", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "SubscriptionTopic", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "SubscriptionTopic", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "SubscriptionTopic", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SubscriptionTopic", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "SubscriptionTopic", "title", element.getTitleElement(), -1);
    }
    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
      composeCanonical(t, "SubscriptionTopic", "derivedFrom", element.getDerivedFrom().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "SubscriptionTopic", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "SubscriptionTopic", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "SubscriptionTopic", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "SubscriptionTopic", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "SubscriptionTopic", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubscriptionTopic", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "SubscriptionTopic", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "SubscriptionTopic", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "SubscriptionTopic", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "SubscriptionTopic", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "SubscriptionTopic", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "SubscriptionTopic", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "SubscriptionTopic", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "SubscriptionTopic", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getResourceTrigger().size(); i++) {
      composeSubscriptionTopicResourceTriggerComponent(t, "SubscriptionTopic", "resourceTrigger", element.getResourceTrigger().get(i), i);
    }
    for (int i = 0; i < element.getEventTrigger().size(); i++) {
      composeSubscriptionTopicEventTriggerComponent(t, "SubscriptionTopic", "eventTrigger", element.getEventTrigger().get(i), i);
    }
    for (int i = 0; i < element.getCanFilterBy().size(); i++) {
      composeSubscriptionTopicCanFilterByComponent(t, "SubscriptionTopic", "canFilterBy", element.getCanFilterBy().get(i), i);
    }
    for (int i = 0; i < element.getNotificationShape().size(); i++) {
      composeSubscriptionTopicNotificationShapeComponent(t, "SubscriptionTopic", "notificationShape", element.getNotificationShape().get(i), i);
    }
  }

  protected void composeSubscriptionTopicResourceTriggerComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicResourceTriggerComponent 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, "resourceTrigger", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubscriptionTopicResourceTriggerComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasResourceElement()) {
      composeUri(t, "SubscriptionTopicResourceTriggerComponent", "resource", element.getResourceElement(), -1);
    }
    for (int i = 0; i < element.getSupportedInteraction().size(); i++) {
      composeEnum(t, "SubscriptionTopicResourceTriggerComponent", "supportedInteraction", element.getSupportedInteraction().get(i), i);
    }
    if (element.hasQueryCriteria()) {
      composeSubscriptionTopicResourceTriggerQueryCriteriaComponent(t, "SubscriptionTopicResourceTriggerComponent", "queryCriteria", element.getQueryCriteria(), -1);
    }
    if (element.hasFhirPathCriteriaElement()) {
      composeString(t, "SubscriptionTopicResourceTriggerComponent", "fhirPathCriteria", element.getFhirPathCriteriaElement(), -1);
    }
  }

  protected void composeSubscriptionTopicResourceTriggerQueryCriteriaComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicResourceTriggerQueryCriteriaComponent 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, "queryCriteria", name, element, index);
    if (element.hasPreviousElement()) {
      composeString(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "previous", element.getPreviousElement(), -1);
    }
    if (element.hasResultForCreateElement()) {
      composeEnum(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "resultForCreate", element.getResultForCreateElement(), -1);
    }
    if (element.hasCurrentElement()) {
      composeString(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "current", element.getCurrentElement(), -1);
    }
    if (element.hasResultForDeleteElement()) {
      composeEnum(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "resultForDelete", element.getResultForDeleteElement(), -1);
    }
    if (element.hasRequireBothElement()) {
      composeBoolean(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "requireBoth", element.getRequireBothElement(), -1);
    }
  }

  protected void composeSubscriptionTopicEventTriggerComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicEventTriggerComponent 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, "eventTrigger", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubscriptionTopicEventTriggerComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasEvent()) {
      composeCodeableConcept(t, "SubscriptionTopicEventTriggerComponent", "event", element.getEvent(), -1);
    }
    if (element.hasResourceElement()) {
      composeUri(t, "SubscriptionTopicEventTriggerComponent", "resource", element.getResourceElement(), -1);
    }
  }

  protected void composeSubscriptionTopicCanFilterByComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicCanFilterByComponent 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, "canFilterBy", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubscriptionTopicCanFilterByComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasResourceElement()) {
      composeUri(t, "SubscriptionTopicCanFilterByComponent", "resource", element.getResourceElement(), -1);
    }
    if (element.hasFilterParameterElement()) {
      composeString(t, "SubscriptionTopicCanFilterByComponent", "filterParameter", element.getFilterParameterElement(), -1);
    }
    if (element.hasFilterDefinitionElement()) {
      composeUri(t, "SubscriptionTopicCanFilterByComponent", "filterDefinition", element.getFilterDefinitionElement(), -1);
    }
    for (int i = 0; i < element.getComparator().size(); i++) {
      composeEnum(t, "SubscriptionTopicCanFilterByComponent", "comparator", element.getComparator().get(i), i);
    }
    for (int i = 0; i < element.getModifier().size(); i++) {
      composeEnum(t, "SubscriptionTopicCanFilterByComponent", "modifier", element.getModifier().get(i), i);
    }
  }

  protected void composeSubscriptionTopicNotificationShapeComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicNotificationShapeComponent 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, "notificationShape", name, element, index);
    if (element.hasResourceElement()) {
      composeUri(t, "SubscriptionTopicNotificationShapeComponent", "resource", element.getResourceElement(), -1);
    }
    for (int i = 0; i < element.getInclude().size(); i++) {
      composeString(t, "SubscriptionTopicNotificationShapeComponent", "include", element.getInclude().get(i), i);
    }
    for (int i = 0; i < element.getRevInclude().size(); i++) {
      composeString(t, "SubscriptionTopicNotificationShapeComponent", "revInclude", element.getRevInclude().get(i), i);
    }
  }

  protected void composeSubstance(Complex parent, String parentType, String name, Substance 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, "Substance", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasInstanceElement()) {
      composeBoolean(t, "Substance", "instance", element.getInstanceElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Substance", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i);
    }
    if (element.hasCode()) {
      composeCodeableReference(t, "Substance", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "Substance", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasExpiryElement()) {
      composeDateTime(t, "Substance", "expiry", element.getExpiryElement(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "Substance", "quantity", element.getQuantity(), -1);
    }
    for (int i = 0; i < element.getIngredient().size(); i++) {
      composeSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i);
    }
  }

  protected void composeSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent 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, "ingredient", name, element, index);
    if (element.hasQuantity()) {
      composeRatio(t, "SubstanceIngredientComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasSubstance()) {
      composeType(t, "SubstanceIngredientComponent", "substance", element.getSubstance(), -1);
    }
  }

  protected void composeSubstanceDefinition(Complex parent, String parentType, String name, SubstanceDefinition 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, "SubstanceDefinition", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "SubstanceDefinition", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "SubstanceDefinition", "version", element.getVersionElement(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "SubstanceDefinition", "status", element.getStatus(), -1);
    }
    for (int i = 0; i < element.getClassification().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinition", "classification", element.getClassification().get(i), i);
    }
    if (element.hasDomain()) {
      composeCodeableConcept(t, "SubstanceDefinition", "domain", element.getDomain(), -1);
    }
    for (int i = 0; i < element.getGrade().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinition", "grade", element.getGrade().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubstanceDefinition", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getInformationSource().size(); i++) {
      composeReference(t, "SubstanceDefinition", "informationSource", element.getInformationSource().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "SubstanceDefinition", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getManufacturer().size(); i++) {
      composeReference(t, "SubstanceDefinition", "manufacturer", element.getManufacturer().get(i), i);
    }
    for (int i = 0; i < element.getSupplier().size(); i++) {
      composeReference(t, "SubstanceDefinition", "supplier", element.getSupplier().get(i), i);
    }
    for (int i = 0; i < element.getMoiety().size(); i++) {
      composeSubstanceDefinitionMoietyComponent(t, "SubstanceDefinition", "moiety", element.getMoiety().get(i), i);
    }
    for (int i = 0; i < element.getCharacterization().size(); i++) {
      composeSubstanceDefinitionCharacterizationComponent(t, "SubstanceDefinition", "characterization", element.getCharacterization().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeSubstanceDefinitionPropertyComponent(t, "SubstanceDefinition", "property", element.getProperty().get(i), i);
    }
    if (element.hasReferenceInformation()) {
      composeReference(t, "SubstanceDefinition", "referenceInformation", element.getReferenceInformation(), -1);
    }
    for (int i = 0; i < element.getMolecularWeight().size(); i++) {
      composeSubstanceDefinitionMolecularWeightComponent(t, "SubstanceDefinition", "molecularWeight", element.getMolecularWeight().get(i), i);
    }
    if (element.hasStructure()) {
      composeSubstanceDefinitionStructureComponent(t, "SubstanceDefinition", "structure", element.getStructure(), -1);
    }
    for (int i = 0; i < element.getCode().size(); i++) {
      composeSubstanceDefinitionCodeComponent(t, "SubstanceDefinition", "code", element.getCode().get(i), i);
    }
    for (int i = 0; i < element.getName().size(); i++) {
      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinition", "name", element.getName().get(i), i);
    }
    for (int i = 0; i < element.getRelationship().size(); i++) {
      composeSubstanceDefinitionRelationshipComponent(t, "SubstanceDefinition", "relationship", element.getRelationship().get(i), i);
    }
    if (element.hasNucleicAcid()) {
      composeReference(t, "SubstanceDefinition", "nucleicAcid", element.getNucleicAcid(), -1);
    }
    if (element.hasPolymer()) {
      composeReference(t, "SubstanceDefinition", "polymer", element.getPolymer(), -1);
    }
    if (element.hasProtein()) {
      composeReference(t, "SubstanceDefinition", "protein", element.getProtein(), -1);
    }
    if (element.hasSourceMaterial()) {
      composeSubstanceDefinitionSourceMaterialComponent(t, "SubstanceDefinition", "sourceMaterial", element.getSourceMaterial(), -1);
    }
  }

  protected void composeSubstanceDefinitionMoietyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMoietyComponent 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, "moiety", name, element, index);
    if (element.hasRole()) {
      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "role", element.getRole(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "SubstanceDefinitionMoietyComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SubstanceDefinitionMoietyComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasStereochemistry()) {
      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "stereochemistry", element.getStereochemistry(), -1);
    }
    if (element.hasOpticalActivity()) {
      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "opticalActivity", element.getOpticalActivity(), -1);
    }
    if (element.hasMolecularFormulaElement()) {
      composeString(t, "SubstanceDefinitionMoietyComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
    }
    if (element.hasAmount()) {
      composeType(t, "SubstanceDefinitionMoietyComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasMeasurementType()) {
      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "measurementType", element.getMeasurementType(), -1);
    }
  }

  protected void composeSubstanceDefinitionCharacterizationComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionCharacterizationComponent 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, "characterization", name, element, index);
    if (element.hasTechnique()) {
      composeCodeableConcept(t, "SubstanceDefinitionCharacterizationComponent", "technique", element.getTechnique(), -1);
    }
    if (element.hasForm()) {
      composeCodeableConcept(t, "SubstanceDefinitionCharacterizationComponent", "form", element.getForm(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "SubstanceDefinitionCharacterizationComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getFile().size(); i++) {
      composeAttachment(t, "SubstanceDefinitionCharacterizationComponent", "file", element.getFile().get(i), i);
    }
  }

  protected void composeSubstanceDefinitionPropertyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionPropertyComponent 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, "SubstanceDefinitionPropertyComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "SubstanceDefinitionPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeSubstanceDefinitionMolecularWeightComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMolecularWeightComponent 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, "molecularWeight", name, element, index);
    if (element.hasMethod()) {
      composeCodeableConcept(t, "SubstanceDefinitionMolecularWeightComponent", "method", element.getMethod(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceDefinitionMolecularWeightComponent", "type", element.getType(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "SubstanceDefinitionMolecularWeightComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeSubstanceDefinitionStructureComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureComponent 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, "structure", name, element, index);
    if (element.hasStereochemistry()) {
      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "stereochemistry", element.getStereochemistry(), -1);
    }
    if (element.hasOpticalActivity()) {
      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "opticalActivity", element.getOpticalActivity(), -1);
    }
    if (element.hasMolecularFormulaElement()) {
      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
    }
    if (element.hasMolecularFormulaByMoietyElement()) {
      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormulaByMoiety", element.getMolecularFormulaByMoietyElement(), -1);
    }
    if (element.hasMolecularWeight()) {
      composeSubstanceDefinitionMolecularWeightComponent(t, "SubstanceDefinitionStructureComponent", "molecularWeight", element.getMolecularWeight(), -1);
    }
    for (int i = 0; i < element.getTechnique().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "technique", element.getTechnique().get(i), i);
    }
    for (int i = 0; i < element.getSourceDocument().size(); i++) {
      composeReference(t, "SubstanceDefinitionStructureComponent", "sourceDocument", element.getSourceDocument().get(i), i);
    }
    for (int i = 0; i < element.getRepresentation().size(); i++) {
      composeSubstanceDefinitionStructureRepresentationComponent(t, "SubstanceDefinitionStructureComponent", "representation", element.getRepresentation().get(i), i);
    }
  }

  protected void composeSubstanceDefinitionStructureRepresentationComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureRepresentationComponent 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, "representation", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "type", element.getType(), -1);
    }
    if (element.hasRepresentationElement()) {
      composeString(t, "SubstanceDefinitionStructureRepresentationComponent", "representation", element.getRepresentationElement(), -1);
    }
    if (element.hasFormat()) {
      composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "format", element.getFormat(), -1);
    }
    if (element.hasDocument()) {
      composeReference(t, "SubstanceDefinitionStructureRepresentationComponent", "document", element.getDocument(), -1);
    }
  }

  protected void composeSubstanceDefinitionCodeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionCodeComponent 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, "code", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "code", element.getCode(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "status", element.getStatus(), -1);
    }
    if (element.hasStatusDateElement()) {
      composeDateTime(t, "SubstanceDefinitionCodeComponent", "statusDate", element.getStatusDateElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "SubstanceDefinitionCodeComponent", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceDefinitionCodeComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceDefinitionNameComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameComponent 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, "name", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "SubstanceDefinitionNameComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "type", element.getType(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "status", element.getStatus(), -1);
    }
    if (element.hasPreferredElement()) {
      composeBoolean(t, "SubstanceDefinitionNameComponent", "preferred", element.getPreferredElement(), -1);
    }
    for (int i = 0; i < element.getLanguage().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "language", element.getLanguage().get(i), i);
    }
    for (int i = 0; i < element.getDomain().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "domain", element.getDomain().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    for (int i = 0; i < element.getSynonym().size(); i++) {
      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "synonym", element.getSynonym().get(i), i);
    }
    for (int i = 0; i < element.getTranslation().size(); i++) {
      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "translation", element.getTranslation().get(i), i);
    }
    for (int i = 0; i < element.getOfficial().size(); i++) {
      composeSubstanceDefinitionNameOfficialComponent(t, "SubstanceDefinitionNameComponent", "official", element.getOfficial().get(i), i);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceDefinitionNameComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceDefinitionNameOfficialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameOfficialComponent 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, "official", name, element, index);
    if (element.hasAuthority()) {
      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "authority", element.getAuthority(), -1);
    }
    if (element.hasStatus()) {
      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "status", element.getStatus(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "SubstanceDefinitionNameOfficialComponent", "date", element.getDateElement(), -1);
    }
  }

  protected void composeSubstanceDefinitionRelationshipComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionRelationshipComponent 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, "relationship", name, element, index);
    if (element.hasSubstanceDefinition()) {
      composeType(t, "SubstanceDefinitionRelationshipComponent", "substanceDefinition", element.getSubstanceDefinition(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "type", element.getType(), -1);
    }
    if (element.hasIsDefiningElement()) {
      composeBoolean(t, "SubstanceDefinitionRelationshipComponent", "isDefining", element.getIsDefiningElement(), -1);
    }
    if (element.hasAmount()) {
      composeType(t, "SubstanceDefinitionRelationshipComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasRatioHighLimitAmount()) {
      composeRatio(t, "SubstanceDefinitionRelationshipComponent", "ratioHighLimitAmount", element.getRatioHighLimitAmount(), -1);
    }
    if (element.hasComparator()) {
      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "comparator", element.getComparator(), -1);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceDefinitionRelationshipComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceDefinitionSourceMaterialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionSourceMaterialComponent 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, "sourceMaterial", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "type", element.getType(), -1);
    }
    if (element.hasGenus()) {
      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "genus", element.getGenus(), -1);
    }
    if (element.hasSpecies()) {
      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "species", element.getSpecies(), -1);
    }
    if (element.hasPart()) {
      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "part", element.getPart(), -1);
    }
    for (int i = 0; i < element.getCountryOfOrigin().size(); i++) {
      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "countryOfOrigin", element.getCountryOfOrigin().get(i), i);
    }
  }

  protected void composeSubstanceNucleicAcid(Complex parent, String parentType, String name, SubstanceNucleicAcid 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, "SubstanceNucleicAcid", name, element, index);
    if (element.hasSequenceType()) {
      composeCodeableConcept(t, "SubstanceNucleicAcid", "sequenceType", element.getSequenceType(), -1);
    }
    if (element.hasNumberOfSubunitsElement()) {
      composeInteger(t, "SubstanceNucleicAcid", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1);
    }
    if (element.hasAreaOfHybridisationElement()) {
      composeString(t, "SubstanceNucleicAcid", "areaOfHybridisation", element.getAreaOfHybridisationElement(), -1);
    }
    if (element.hasOligoNucleotideType()) {
      composeCodeableConcept(t, "SubstanceNucleicAcid", "oligoNucleotideType", element.getOligoNucleotideType(), -1);
    }
    for (int i = 0; i < element.getSubunit().size(); i++) {
      composeSubstanceNucleicAcidSubunitComponent(t, "SubstanceNucleicAcid", "subunit", element.getSubunit().get(i), i);
    }
  }

  protected void composeSubstanceNucleicAcidSubunitComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitComponent 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, "subunit", name, element, index);
    if (element.hasSubunitElement()) {
      composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "subunit", element.getSubunitElement(), -1);
    }
    if (element.hasSequenceElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasLengthElement()) {
      composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "length", element.getLengthElement(), -1);
    }
    if (element.hasSequenceAttachment()) {
      composeAttachment(t, "SubstanceNucleicAcidSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1);
    }
    if (element.hasFivePrime()) {
      composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "fivePrime", element.getFivePrime(), -1);
    }
    if (element.hasThreePrime()) {
      composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "threePrime", element.getThreePrime(), -1);
    }
    for (int i = 0; i < element.getLinkage().size(); i++) {
      composeSubstanceNucleicAcidSubunitLinkageComponent(t, "SubstanceNucleicAcidSubunitComponent", "linkage", element.getLinkage().get(i), i);
    }
    for (int i = 0; i < element.getSugar().size(); i++) {
      composeSubstanceNucleicAcidSubunitSugarComponent(t, "SubstanceNucleicAcidSubunitComponent", "sugar", element.getSugar().get(i), i);
    }
  }

  protected void composeSubstanceNucleicAcidSubunitLinkageComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitLinkageComponent 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, "linkage", name, element, index);
    if (element.hasConnectivityElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "connectivity", element.getConnectivityElement(), -1);
    }
    if (element.hasIdentifier()) {
      composeIdentifier(t, "SubstanceNucleicAcidSubunitLinkageComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasResidueSiteElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "residueSite", element.getResidueSiteElement(), -1);
    }
  }

  protected void composeSubstanceNucleicAcidSubunitSugarComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitSugarComponent 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, "sugar", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "SubstanceNucleicAcidSubunitSugarComponent", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasResidueSiteElement()) {
      composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "residueSite", element.getResidueSiteElement(), -1);
    }
  }

  protected void composeSubstancePolymer(Complex parent, String parentType, String name, SubstancePolymer 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, "SubstancePolymer", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "SubstancePolymer", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasClass_()) {
      composeCodeableConcept(t, "SubstancePolymer", "class", element.getClass_(), -1);
    }
    if (element.hasGeometry()) {
      composeCodeableConcept(t, "SubstancePolymer", "geometry", element.getGeometry(), -1);
    }
    for (int i = 0; i < element.getCopolymerConnectivity().size(); i++) {
      composeCodeableConcept(t, "SubstancePolymer", "copolymerConnectivity", element.getCopolymerConnectivity().get(i), i);
    }
    if (element.hasModificationElement()) {
      composeString(t, "SubstancePolymer", "modification", element.getModificationElement(), -1);
    }
    for (int i = 0; i < element.getMonomerSet().size(); i++) {
      composeSubstancePolymerMonomerSetComponent(t, "SubstancePolymer", "monomerSet", element.getMonomerSet().get(i), i);
    }
    for (int i = 0; i < element.getRepeat().size(); i++) {
      composeSubstancePolymerRepeatComponent(t, "SubstancePolymer", "repeat", element.getRepeat().get(i), i);
    }
  }

  protected void composeSubstancePolymerMonomerSetComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetComponent 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, "monomerSet", name, element, index);
    if (element.hasRatioType()) {
      composeCodeableConcept(t, "SubstancePolymerMonomerSetComponent", "ratioType", element.getRatioType(), -1);
    }
    for (int i = 0; i < element.getStartingMaterial().size(); i++) {
      composeSubstancePolymerMonomerSetStartingMaterialComponent(t, "SubstancePolymerMonomerSetComponent", "startingMaterial", element.getStartingMaterial().get(i), i);
    }
  }

  protected void composeSubstancePolymerMonomerSetStartingMaterialComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetStartingMaterialComponent 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, "startingMaterial", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "code", element.getCode(), -1);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "category", element.getCategory(), -1);
    }
    if (element.hasIsDefiningElement()) {
      composeBoolean(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "isDefining", element.getIsDefiningElement(), -1);
    }
    if (element.hasAmount()) {
      composeQuantity(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "amount", element.getAmount(), -1);
    }
  }

  protected void composeSubstancePolymerRepeatComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatComponent 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, "repeat", name, element, index);
    if (element.hasAverageMolecularFormulaElement()) {
      composeString(t, "SubstancePolymerRepeatComponent", "averageMolecularFormula", element.getAverageMolecularFormulaElement(), -1);
    }
    if (element.hasRepeatUnitAmountType()) {
      composeCodeableConcept(t, "SubstancePolymerRepeatComponent", "repeatUnitAmountType", element.getRepeatUnitAmountType(), -1);
    }
    for (int i = 0; i < element.getRepeatUnit().size(); i++) {
      composeSubstancePolymerRepeatRepeatUnitComponent(t, "SubstancePolymerRepeatComponent", "repeatUnit", element.getRepeatUnit().get(i), i);
    }
  }

  protected void composeSubstancePolymerRepeatRepeatUnitComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitComponent 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, "repeatUnit", name, element, index);
    if (element.hasUnitElement()) {
      composeString(t, "SubstancePolymerRepeatRepeatUnitComponent", "unit", element.getUnitElement(), -1);
    }
    if (element.hasOrientation()) {
      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitComponent", "orientation", element.getOrientation(), -1);
    }
    if (element.hasAmountElement()) {
      composeInteger(t, "SubstancePolymerRepeatRepeatUnitComponent", "amount", element.getAmountElement(), -1);
    }
    for (int i = 0; i < element.getDegreeOfPolymerisation().size(); i++) {
      composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "degreeOfPolymerisation", element.getDegreeOfPolymerisation().get(i), i);
    }
    for (int i = 0; i < element.getStructuralRepresentation().size(); i++) {
      composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "structuralRepresentation", element.getStructuralRepresentation().get(i), i);
    }
  }

  protected void composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent 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, "degreeOfPolymerisation", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "type", element.getType(), -1);
    }
    if (element.hasAverageElement()) {
      composeInteger(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "average", element.getAverageElement(), -1);
    }
    if (element.hasLowElement()) {
      composeInteger(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "low", element.getLowElement(), -1);
    }
    if (element.hasHighElement()) {
      composeInteger(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "high", element.getHighElement(), -1);
    }
  }

  protected void composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent 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, "structuralRepresentation", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "type", element.getType(), -1);
    }
    if (element.hasRepresentationElement()) {
      composeString(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "representation", element.getRepresentationElement(), -1);
    }
    if (element.hasFormat()) {
      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "format", element.getFormat(), -1);
    }
    if (element.hasAttachment()) {
      composeAttachment(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "attachment", element.getAttachment(), -1);
    }
  }

  protected void composeSubstanceProtein(Complex parent, String parentType, String name, SubstanceProtein 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, "SubstanceProtein", name, element, index);
    if (element.hasSequenceType()) {
      composeCodeableConcept(t, "SubstanceProtein", "sequenceType", element.getSequenceType(), -1);
    }
    if (element.hasNumberOfSubunitsElement()) {
      composeInteger(t, "SubstanceProtein", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1);
    }
    for (int i = 0; i < element.getDisulfideLinkage().size(); i++) {
      composeString(t, "SubstanceProtein", "disulfideLinkage", element.getDisulfideLinkage().get(i), i);
    }
    for (int i = 0; i < element.getSubunit().size(); i++) {
      composeSubstanceProteinSubunitComponent(t, "SubstanceProtein", "subunit", element.getSubunit().get(i), i);
    }
  }

  protected void composeSubstanceProteinSubunitComponent(Complex parent, String parentType, String name, SubstanceProtein.SubstanceProteinSubunitComponent 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, "subunit", name, element, index);
    if (element.hasSubunitElement()) {
      composeInteger(t, "SubstanceProteinSubunitComponent", "subunit", element.getSubunitElement(), -1);
    }
    if (element.hasSequenceElement()) {
      composeString(t, "SubstanceProteinSubunitComponent", "sequence", element.getSequenceElement(), -1);
    }
    if (element.hasLengthElement()) {
      composeInteger(t, "SubstanceProteinSubunitComponent", "length", element.getLengthElement(), -1);
    }
    if (element.hasSequenceAttachment()) {
      composeAttachment(t, "SubstanceProteinSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1);
    }
    if (element.hasNTerminalModificationId()) {
      composeIdentifier(t, "SubstanceProteinSubunitComponent", "nTerminalModificationId", element.getNTerminalModificationId(), -1);
    }
    if (element.hasNTerminalModificationElement()) {
      composeString(t, "SubstanceProteinSubunitComponent", "nTerminalModification", element.getNTerminalModificationElement(), -1);
    }
    if (element.hasCTerminalModificationId()) {
      composeIdentifier(t, "SubstanceProteinSubunitComponent", "cTerminalModificationId", element.getCTerminalModificationId(), -1);
    }
    if (element.hasCTerminalModificationElement()) {
      composeString(t, "SubstanceProteinSubunitComponent", "cTerminalModification", element.getCTerminalModificationElement(), -1);
    }
  }

  protected void composeSubstanceReferenceInformation(Complex parent, String parentType, String name, SubstanceReferenceInformation 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, "SubstanceReferenceInformation", name, element, index);
    if (element.hasCommentElement()) {
      composeString(t, "SubstanceReferenceInformation", "comment", element.getCommentElement(), -1);
    }
    for (int i = 0; i < element.getGene().size(); i++) {
      composeSubstanceReferenceInformationGeneComponent(t, "SubstanceReferenceInformation", "gene", element.getGene().get(i), i);
    }
    for (int i = 0; i < element.getGeneElement().size(); i++) {
      composeSubstanceReferenceInformationGeneElementComponent(t, "SubstanceReferenceInformation", "geneElement", element.getGeneElement().get(i), i);
    }
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeSubstanceReferenceInformationTargetComponent(t, "SubstanceReferenceInformation", "target", element.getTarget().get(i), i);
    }
  }

  protected void composeSubstanceReferenceInformationGeneComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneComponent 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, "gene", name, element, index);
    if (element.hasGeneSequenceOrigin()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "geneSequenceOrigin", element.getGeneSequenceOrigin(), -1);
    }
    if (element.hasGene()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "gene", element.getGene(), -1);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceReferenceInformationGeneComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceReferenceInformationGeneElementComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneElementComponent 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, "geneElement", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationGeneElementComponent", "type", element.getType(), -1);
    }
    if (element.hasElement()) {
      composeIdentifier(t, "SubstanceReferenceInformationGeneElementComponent", "element", element.getElement(), -1);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceReferenceInformationGeneElementComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceReferenceInformationTargetComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationTargetComponent 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.hasTarget()) {
      composeIdentifier(t, "SubstanceReferenceInformationTargetComponent", "target", element.getTarget(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "type", element.getType(), -1);
    }
    if (element.hasInteraction()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "interaction", element.getInteraction(), -1);
    }
    if (element.hasOrganism()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organism", element.getOrganism(), -1);
    }
    if (element.hasOrganismType()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organismType", element.getOrganismType(), -1);
    }
    if (element.hasAmount()) {
      composeType(t, "SubstanceReferenceInformationTargetComponent", "amount", element.getAmount(), -1);
    }
    if (element.hasAmountType()) {
      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "amountType", element.getAmountType(), -1);
    }
    for (int i = 0; i < element.getSource().size(); i++) {
      composeReference(t, "SubstanceReferenceInformationTargetComponent", "source", element.getSource().get(i), i);
    }
  }

  protected void composeSubstanceSourceMaterial(Complex parent, String parentType, String name, SubstanceSourceMaterial 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, "SubstanceSourceMaterial", name, element, index);
    if (element.hasSourceMaterialClass()) {
      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialClass", element.getSourceMaterialClass(), -1);
    }
    if (element.hasSourceMaterialType()) {
      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialType", element.getSourceMaterialType(), -1);
    }
    if (element.hasSourceMaterialState()) {
      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialState", element.getSourceMaterialState(), -1);
    }
    if (element.hasOrganismId()) {
      composeIdentifier(t, "SubstanceSourceMaterial", "organismId", element.getOrganismId(), -1);
    }
    if (element.hasOrganismNameElement()) {
      composeString(t, "SubstanceSourceMaterial", "organismName", element.getOrganismNameElement(), -1);
    }
    for (int i = 0; i < element.getParentSubstanceId().size(); i++) {
      composeIdentifier(t, "SubstanceSourceMaterial", "parentSubstanceId", element.getParentSubstanceId().get(i), i);
    }
    for (int i = 0; i < element.getParentSubstanceName().size(); i++) {
      composeString(t, "SubstanceSourceMaterial", "parentSubstanceName", element.getParentSubstanceName().get(i), i);
    }
    for (int i = 0; i < element.getCountryOfOrigin().size(); i++) {
      composeCodeableConcept(t, "SubstanceSourceMaterial", "countryOfOrigin", element.getCountryOfOrigin().get(i), i);
    }
    for (int i = 0; i < element.getGeographicalLocation().size(); i++) {
      composeString(t, "SubstanceSourceMaterial", "geographicalLocation", element.getGeographicalLocation().get(i), i);
    }
    if (element.hasDevelopmentStage()) {
      composeCodeableConcept(t, "SubstanceSourceMaterial", "developmentStage", element.getDevelopmentStage(), -1);
    }
    for (int i = 0; i < element.getFractionDescription().size(); i++) {
      composeSubstanceSourceMaterialFractionDescriptionComponent(t, "SubstanceSourceMaterial", "fractionDescription", element.getFractionDescription().get(i), i);
    }
    if (element.hasOrganism()) {
      composeSubstanceSourceMaterialOrganismComponent(t, "SubstanceSourceMaterial", "organism", element.getOrganism(), -1);
    }
    for (int i = 0; i < element.getPartDescription().size(); i++) {
      composeSubstanceSourceMaterialPartDescriptionComponent(t, "SubstanceSourceMaterial", "partDescription", element.getPartDescription().get(i), i);
    }
  }

  protected void composeSubstanceSourceMaterialFractionDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialFractionDescriptionComponent 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, "fractionDescription", name, element, index);
    if (element.hasFractionElement()) {
      composeString(t, "SubstanceSourceMaterialFractionDescriptionComponent", "fraction", element.getFractionElement(), -1);
    }
    if (element.hasMaterialType()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialFractionDescriptionComponent", "materialType", element.getMaterialType(), -1);
    }
  }

  protected void composeSubstanceSourceMaterialOrganismComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismComponent 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, "organism", name, element, index);
    if (element.hasFamily()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "family", element.getFamily(), -1);
    }
    if (element.hasGenus()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "genus", element.getGenus(), -1);
    }
    if (element.hasSpecies()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "species", element.getSpecies(), -1);
    }
    if (element.hasIntraspecificType()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificType", element.getIntraspecificType(), -1);
    }
    if (element.hasIntraspecificDescriptionElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificDescription", element.getIntraspecificDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeSubstanceSourceMaterialOrganismAuthorComponent(t, "SubstanceSourceMaterialOrganismComponent", "author", element.getAuthor().get(i), i);
    }
    if (element.hasHybrid()) {
      composeSubstanceSourceMaterialOrganismHybridComponent(t, "SubstanceSourceMaterialOrganismComponent", "hybrid", element.getHybrid(), -1);
    }
    if (element.hasOrganismGeneral()) {
      composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(t, "SubstanceSourceMaterialOrganismComponent", "organismGeneral", element.getOrganismGeneral(), -1);
    }
  }

  protected void composeSubstanceSourceMaterialOrganismAuthorComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismAuthorComponent 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, "author", name, element, index);
    if (element.hasAuthorType()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorType", element.getAuthorType(), -1);
    }
    if (element.hasAuthorDescriptionElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorDescription", element.getAuthorDescriptionElement(), -1);
    }
  }

  protected void composeSubstanceSourceMaterialOrganismHybridComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismHybridComponent 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, "hybrid", name, element, index);
    if (element.hasMaternalOrganismIdElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismId", element.getMaternalOrganismIdElement(), -1);
    }
    if (element.hasMaternalOrganismNameElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismName", element.getMaternalOrganismNameElement(), -1);
    }
    if (element.hasPaternalOrganismIdElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismId", element.getPaternalOrganismIdElement(), -1);
    }
    if (element.hasPaternalOrganismNameElement()) {
      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismName", element.getPaternalOrganismNameElement(), -1);
    }
    if (element.hasHybridType()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismHybridComponent", "hybridType", element.getHybridType(), -1);
    }
  }

  protected void composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismOrganismGeneralComponent 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, "organismGeneral", name, element, index);
    if (element.hasKingdom()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "kingdom", element.getKingdom(), -1);
    }
    if (element.hasPhylum()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "phylum", element.getPhylum(), -1);
    }
    if (element.hasClass_()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "class", element.getClass_(), -1);
    }
    if (element.hasOrder()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "order", element.getOrder(), -1);
    }
  }

  protected void composeSubstanceSourceMaterialPartDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialPartDescriptionComponent 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, "partDescription", name, element, index);
    if (element.hasPart()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "part", element.getPart(), -1);
    }
    if (element.hasPartLocation()) {
      composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "partLocation", element.getPartLocation(), -1);
    }
  }

  protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery 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, "SupplyDelivery", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier().get(i), i);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1);
    }
    if (element.hasType()) {
      composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1);
    }
    for (int i = 0; i < element.getSuppliedItem().size(); i++) {
      composeSupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem().get(i), i);
    }
    if (element.hasOccurrence()) {
      composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasSupplier()) {
      composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1);
    }
    if (element.hasDestination()) {
      composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1);
    }
    for (int i = 0; i < element.getReceiver().size(); i++) {
      composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i);
    }
  }

  protected void composeSupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent 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, "suppliedItem", name, element, index);
    if (element.hasQuantity()) {
      composeQuantity(t, "SupplyDeliverySuppliedItemComponent", "quantity", element.getQuantity(), -1);
    }
    if (element.hasItem()) {
      composeType(t, "SupplyDeliverySuppliedItemComponent", "item", element.getItem(), -1);
    }
  }

  protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest 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, "SupplyRequest", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "SupplyRequest", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasCategory()) {
      composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDeliverFor()) {
      composeReference(t, "SupplyRequest", "deliverFor", element.getDeliverFor(), -1);
    }
    if (element.hasItem()) {
      composeCodeableReference(t, "SupplyRequest", "item", element.getItem(), -1);
    }
    if (element.hasQuantity()) {
      composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeSupplyRequestParameterComponent(t, "SupplyRequest", "parameter", element.getParameter().get(i), i);
    }
    if (element.hasOccurrence()) {
      composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "SupplyRequest", "requester", element.getRequester(), -1);
    }
    for (int i = 0; i < element.getSupplier().size(); i++) {
      composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "SupplyRequest", "reason", element.getReason().get(i), i);
    }
    if (element.hasDeliverFrom()) {
      composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1);
    }
    if (element.hasDeliverTo()) {
      composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1);
    }
  }

  protected void composeSupplyRequestParameterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestParameterComponent 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, "parameter", name, element, index);
    if (element.hasCode()) {
      composeCodeableConcept(t, "SupplyRequestParameterComponent", "code", element.getCode(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "SupplyRequestParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeTask(Complex parent, String parentType, String name, Task 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, "Task", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasInstantiatesCanonicalElement()) {
      composeCanonical(t, "Task", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
    }
    if (element.hasInstantiatesUriElement()) {
      composeUri(t, "Task", "instantiatesUri", element.getInstantiatesUriElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "Task", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Task", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableReference(t, "Task", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasBusinessStatus()) {
      composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "Task", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "Task", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasDoNotPerformElement()) {
      composeBoolean(t, "Task", "doNotPerform", element.getDoNotPerformElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Task", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "Task", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasFocus()) {
      composeReference(t, "Task", "focus", element.getFocus(), -1);
    }
    if (element.hasFor()) {
      composeReference(t, "Task", "for", element.getFor(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Task", "encounter", element.getEncounter(), -1);
    }
    if (element.hasRequestedPeriod()) {
      composePeriod(t, "Task", "requestedPeriod", element.getRequestedPeriod(), -1);
    }
    if (element.hasExecutionPeriod()) {
      composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasLastModifiedElement()) {
      composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "Task", "requester", element.getRequester(), -1);
    }
    for (int i = 0; i < element.getRequestedPerformer().size(); i++) {
      composeCodeableReference(t, "Task", "requestedPerformer", element.getRequestedPerformer().get(i), i);
    }
    if (element.hasOwner()) {
      composeReference(t, "Task", "owner", element.getOwner(), -1);
    }
    for (int i = 0; i < element.getPerformer().size(); i++) {
      composeTaskPerformerComponent(t, "Task", "performer", element.getPerformer().get(i), i);
    }
    if (element.hasLocation()) {
      composeReference(t, "Task", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getReason().size(); i++) {
      composeCodeableReference(t, "Task", "reason", element.getReason().get(i), i);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeReference(t, "Task", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Task", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
      composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i);
    }
    if (element.hasRestriction()) {
      composeTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composeTaskInputComponent(t, "Task", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getOutput().size(); i++) {
      composeTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i);
    }
  }

  protected void composeTaskPerformerComponent(Complex parent, String parentType, String name, Task.TaskPerformerComponent 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, "TaskPerformerComponent", "function", element.getFunction(), -1);
    }
    if (element.hasActor()) {
      composeReference(t, "TaskPerformerComponent", "actor", element.getActor(), -1);
    }
  }

  protected void composeTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent 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, "restriction", name, element, index);
    if (element.hasRepetitionsElement()) {
      composePositiveInt(t, "TaskRestrictionComponent", "repetitions", element.getRepetitionsElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "TaskRestrictionComponent", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getRecipient().size(); i++) {
      composeReference(t, "TaskRestrictionComponent", "recipient", element.getRecipient().get(i), i);
    }
  }

  protected void composeTaskInputComponent(Complex parent, String parentType, String name, Task.TaskInputComponent 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, "input", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "TaskInputComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "TaskInputComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent 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, "output", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "TaskOutputComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "TaskOutputComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeTerminologyCapabilities(Complex parent, String parentType, String name, TerminologyCapabilities 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, "TerminologyCapabilities", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "TerminologyCapabilities", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "TerminologyCapabilities", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "TerminologyCapabilities", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "TerminologyCapabilities", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "TerminologyCapabilities", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "TerminologyCapabilities", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "TerminologyCapabilities", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "TerminologyCapabilities", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "TerminologyCapabilities", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "TerminologyCapabilities", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "TerminologyCapabilities", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "TerminologyCapabilities", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "TerminologyCapabilities", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasKindElement()) {
      composeEnum(t, "TerminologyCapabilities", "kind", element.getKindElement(), -1);
    }
    if (element.hasSoftware()) {
      composeTerminologyCapabilitiesSoftwareComponent(t, "TerminologyCapabilities", "software", element.getSoftware(), -1);
    }
    if (element.hasImplementation()) {
      composeTerminologyCapabilitiesImplementationComponent(t, "TerminologyCapabilities", "implementation", element.getImplementation(), -1);
    }
    if (element.hasLockedDateElement()) {
      composeBoolean(t, "TerminologyCapabilities", "lockedDate", element.getLockedDateElement(), -1);
    }
    for (int i = 0; i < element.getCodeSystem().size(); i++) {
      composeTerminologyCapabilitiesCodeSystemComponent(t, "TerminologyCapabilities", "codeSystem", element.getCodeSystem().get(i), i);
    }
    if (element.hasExpansion()) {
      composeTerminologyCapabilitiesExpansionComponent(t, "TerminologyCapabilities", "expansion", element.getExpansion(), -1);
    }
    if (element.hasCodeSearchElement()) {
      composeEnum(t, "TerminologyCapabilities", "codeSearch", element.getCodeSearchElement(), -1);
    }
    if (element.hasValidateCode()) {
      composeTerminologyCapabilitiesValidateCodeComponent(t, "TerminologyCapabilities", "validateCode", element.getValidateCode(), -1);
    }
    if (element.hasTranslation()) {
      composeTerminologyCapabilitiesTranslationComponent(t, "TerminologyCapabilities", "translation", element.getTranslation(), -1);
    }
    if (element.hasClosure()) {
      composeTerminologyCapabilitiesClosureComponent(t, "TerminologyCapabilities", "closure", element.getClosure(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesSoftwareComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesSoftwareComponent 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, "TerminologyCapabilitiesSoftwareComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "TerminologyCapabilitiesSoftwareComponent", "version", element.getVersionElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesImplementationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesImplementationComponent 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()) {
      composeString(t, "TerminologyCapabilitiesImplementationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "TerminologyCapabilitiesImplementationComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesCodeSystemComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemComponent 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, "codeSystem", name, element, index);
    if (element.hasUriElement()) {
      composeCanonical(t, "TerminologyCapabilitiesCodeSystemComponent", "uri", element.getUriElement(), -1);
    }
    for (int i = 0; i < element.getVersion().size(); i++) {
      composeTerminologyCapabilitiesCodeSystemVersionComponent(t, "TerminologyCapabilitiesCodeSystemComponent", "version", element.getVersion().get(i), i);
    }
    if (element.hasContentElement()) {
      composeEnum(t, "TerminologyCapabilitiesCodeSystemComponent", "content", element.getContentElement(), -1);
    }
    if (element.hasSubsumptionElement()) {
      composeBoolean(t, "TerminologyCapabilitiesCodeSystemComponent", "subsumption", element.getSubsumptionElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesCodeSystemVersionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionComponent 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.hasCodeElement()) {
      composeString(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasIsDefaultElement()) {
      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "isDefault", element.getIsDefaultElement(), -1);
    }
    if (element.hasCompositionalElement()) {
      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "compositional", element.getCompositionalElement(), -1);
    }
    for (int i = 0; i < element.getLanguage().size(); i++) {
      composeEnum(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "language", element.getLanguage().get(i), i);
    }
    for (int i = 0; i < element.getFilter().size(); i++) {
      composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "filter", element.getFilter().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "property", element.getProperty().get(i), i);
    }
  }

  protected void composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionFilterComponent 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, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "code", element.getCodeElement(), -1);
    }
    for (int i = 0; i < element.getOp().size(); i++) {
      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "op", element.getOp().get(i), i);
    }
  }

  protected void composeTerminologyCapabilitiesExpansionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionComponent 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, "expansion", name, element, index);
    if (element.hasHierarchicalElement()) {
      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "hierarchical", element.getHierarchicalElement(), -1);
    }
    if (element.hasPagingElement()) {
      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "paging", element.getPagingElement(), -1);
    }
    if (element.hasIncompleteElement()) {
      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "incomplete", element.getIncompleteElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeTerminologyCapabilitiesExpansionParameterComponent(t, "TerminologyCapabilitiesExpansionComponent", "parameter", element.getParameter().get(i), i);
    }
    if (element.hasTextFilterElement()) {
      composeMarkdown(t, "TerminologyCapabilitiesExpansionComponent", "textFilter", element.getTextFilterElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesExpansionParameterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionParameterComponent 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, "parameter", name, element, index);
    if (element.hasNameElement()) {
      composeCode(t, "TerminologyCapabilitiesExpansionParameterComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDocumentationElement()) {
      composeString(t, "TerminologyCapabilitiesExpansionParameterComponent", "documentation", element.getDocumentationElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesValidateCodeComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesValidateCodeComponent 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, "validateCode", name, element, index);
    if (element.hasTranslationsElement()) {
      composeBoolean(t, "TerminologyCapabilitiesValidateCodeComponent", "translations", element.getTranslationsElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesTranslationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesTranslationComponent 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, "translation", name, element, index);
    if (element.hasNeedsMapElement()) {
      composeBoolean(t, "TerminologyCapabilitiesTranslationComponent", "needsMap", element.getNeedsMapElement(), -1);
    }
  }

  protected void composeTerminologyCapabilitiesClosureComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesClosureComponent 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, "closure", name, element, index);
    if (element.hasTranslationElement()) {
      composeBoolean(t, "TerminologyCapabilitiesClosureComponent", "translation", element.getTranslationElement(), -1);
    }
  }

  protected void composeTestPlan(Complex parent, String parentType, String name, TestPlan 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, "TestPlan", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "TestPlan", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "TestPlan", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "TestPlan", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "TestPlan", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "TestPlan", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "TestPlan", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "TestPlan", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "TestPlan", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "TestPlan", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "TestPlan", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "TestPlan", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "TestPlan", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "TestPlan", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "TestPlan", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "TestPlan", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "TestPlan", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "TestPlan", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getCategory().size(); i++) {
      composeCodeableConcept(t, "TestPlan", "category", element.getCategory().get(i), i);
    }
    for (int i = 0; i < element.getScope().size(); i++) {
      composeReference(t, "TestPlan", "scope", element.getScope().get(i), i);
    }
    if (element.hasTestToolsElement()) {
      composeMarkdown(t, "TestPlan", "testTools", element.getTestToolsElement(), -1);
    }
    for (int i = 0; i < element.getDependency().size(); i++) {
      composeTestPlanDependencyComponent(t, "TestPlan", "dependency", element.getDependency().get(i), i);
    }
    if (element.hasExitCriteriaElement()) {
      composeMarkdown(t, "TestPlan", "exitCriteria", element.getExitCriteriaElement(), -1);
    }
    for (int i = 0; i < element.getTestCase().size(); i++) {
      composeTestPlanTestCaseComponent(t, "TestPlan", "testCase", element.getTestCase().get(i), i);
    }
  }

  protected void composeTestPlanDependencyComponent(Complex parent, String parentType, String name, TestPlan.TestPlanDependencyComponent 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, "dependency", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "TestPlanDependencyComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasPredecessor()) {
      composeReference(t, "TestPlanDependencyComponent", "predecessor", element.getPredecessor(), -1);
    }
  }

  protected void composeTestPlanTestCaseComponent(Complex parent, String parentType, String name, TestPlan.TestPlanTestCaseComponent 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, "testCase", name, element, index);
    if (element.hasSequenceElement()) {
      composeInteger(t, "TestPlanTestCaseComponent", "sequence", element.getSequenceElement(), -1);
    }
    for (int i = 0; i < element.getScope().size(); i++) {
      composeReference(t, "TestPlanTestCaseComponent", "scope", element.getScope().get(i), i);
    }
    for (int i = 0; i < element.getDependency().size(); i++) {
      composeTestPlanTestCaseDependencyComponent(t, "TestPlanTestCaseComponent", "dependency", element.getDependency().get(i), i);
    }
    for (int i = 0; i < element.getTestRun().size(); i++) {
      composeTestPlanTestCaseTestRunComponent(t, "TestPlanTestCaseComponent", "testRun", element.getTestRun().get(i), i);
    }
    for (int i = 0; i < element.getTestData().size(); i++) {
      composeTestPlanTestCaseTestDataComponent(t, "TestPlanTestCaseComponent", "testData", element.getTestData().get(i), i);
    }
    for (int i = 0; i < element.getAssertion().size(); i++) {
      composeTestPlanTestCaseAssertionComponent(t, "TestPlanTestCaseComponent", "assertion", element.getAssertion().get(i), i);
    }
  }

  protected void composeTestPlanTestCaseDependencyComponent(Complex parent, String parentType, String name, TestPlan.TestCaseDependencyComponent 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, "dependency", name, element, index);
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "TestCaseDependencyComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasPredecessor()) {
      composeReference(t, "TestCaseDependencyComponent", "predecessor", element.getPredecessor(), -1);
    }
  }

  protected void composeTestPlanTestCaseTestRunComponent(Complex parent, String parentType, String name, TestPlan.TestPlanTestCaseTestRunComponent 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, "testRun", name, element, index);
    if (element.hasNarrativeElement()) {
      composeMarkdown(t, "TestPlanTestCaseTestRunComponent", "narrative", element.getNarrativeElement(), -1);
    }
    if (element.hasScript()) {
      composeTestPlanTestCaseTestRunScriptComponent(t, "TestPlanTestCaseTestRunComponent", "script", element.getScript(), -1);
    }
  }

  protected void composeTestPlanTestCaseTestRunScriptComponent(Complex parent, String parentType, String name, TestPlan.TestPlanTestCaseTestRunScriptComponent 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, "script", name, element, index);
    if (element.hasLanguage()) {
      composeCodeableConcept(t, "TestPlanTestCaseTestRunScriptComponent", "language", element.getLanguage(), -1);
    }
    if (element.hasSource()) {
      composeType(t, "TestPlanTestCaseTestRunScriptComponent", "source", element.getSource(), -1);
    }
  }

  protected void composeTestPlanTestCaseTestDataComponent(Complex parent, String parentType, String name, TestPlan.TestPlanTestCaseTestDataComponent 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, "testData", name, element, index);
    if (element.hasType()) {
      composeCoding(t, "TestPlanTestCaseTestDataComponent", "type", element.getType(), -1);
    }
    if (element.hasContent()) {
      composeReference(t, "TestPlanTestCaseTestDataComponent", "content", element.getContent(), -1);
    }
    if (element.hasSource()) {
      composeType(t, "TestPlanTestCaseTestDataComponent", "source", element.getSource(), -1);
    }
  }

  protected void composeTestPlanTestCaseAssertionComponent(Complex parent, String parentType, String name, TestPlan.TestPlanTestCaseAssertionComponent 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, "assertion", name, element, index);
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "TestPlanTestCaseAssertionComponent", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getObject().size(); i++) {
      composeCodeableReference(t, "TestPlanTestCaseAssertionComponent", "object", element.getObject().get(i), i);
    }
    for (int i = 0; i < element.getResult().size(); i++) {
      composeCodeableReference(t, "TestPlanTestCaseAssertionComponent", "result", element.getResult().get(i), i);
    }
  }

  protected void composeTestReport(Complex parent, String parentType, String name, TestReport 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, "TestReport", name, element, index);
    if (element.hasIdentifier()) {
      composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "TestReport", "name", element.getNameElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "TestReport", "status", element.getStatusElement(), -1);
    }
    if (element.hasTestScriptElement()) {
      composeCanonical(t, "TestReport", "testScript", element.getTestScriptElement(), -1);
    }
    if (element.hasResultElement()) {
      composeEnum(t, "TestReport", "result", element.getResultElement(), -1);
    }
    if (element.hasScoreElement()) {
      composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1);
    }
    if (element.hasTesterElement()) {
      composeString(t, "TestReport", "tester", element.getTesterElement(), -1);
    }
    if (element.hasIssuedElement()) {
      composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1);
    }
    for (int i = 0; i < element.getParticipant().size(); i++) {
      composeTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i);
    }
    if (element.hasSetup()) {
      composeTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1);
    }
    for (int i = 0; i < element.getTest().size(); i++) {
      composeTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i);
    }
    if (element.hasTeardown()) {
      composeTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1);
    }
  }

  protected void composeTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent 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, "TestReportParticipantComponent", "type", element.getTypeElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "TestReportParticipantComponent", "uri", element.getUriElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "TestReportParticipantComponent", "display", element.getDisplayElement(), -1);
    }
  }

  protected void composeTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent 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, "setup", name, element, index);
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestReportSetupActionComponent(t, "TestReportSetupComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent 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.hasOperation()) {
      composeTestReportSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1);
    }
    if (element.hasAssert()) {
      composeTestReportSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
    }
  }

  protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent 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.hasResultElement()) {
      composeEnum(t, "SetupActionOperationComponent", "result", element.getResultElement(), -1);
    }
    if (element.hasMessageElement()) {
      composeMarkdown(t, "SetupActionOperationComponent", "message", element.getMessageElement(), -1);
    }
    if (element.hasDetailElement()) {
      composeUri(t, "SetupActionOperationComponent", "detail", element.getDetailElement(), -1);
    }
  }

  protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent 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, "assert", name, element, index);
    if (element.hasResultElement()) {
      composeEnum(t, "SetupActionAssertComponent", "result", element.getResultElement(), -1);
    }
    if (element.hasMessageElement()) {
      composeMarkdown(t, "SetupActionAssertComponent", "message", element.getMessageElement(), -1);
    }
    if (element.hasDetailElement()) {
      composeString(t, "SetupActionAssertComponent", "detail", element.getDetailElement(), -1);
    }
    for (int i = 0; i < element.getRequirement().size(); i++) {
      composeTestReportSetupActionAssertRequirementComponent(t, "SetupActionAssertComponent", "requirement", element.getRequirement().get(i), i);
    }
  }

  protected void composeTestReportSetupActionAssertRequirementComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertRequirementComponent 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, "requirement", name, element, index);
    if (element.hasLink()) {
      composeType(t, "SetupActionAssertRequirementComponent", "link", element.getLink(), -1);
    }
  }

  protected void composeTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent 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, "test", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "TestReportTestComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "TestReportTestComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestReportTestActionComponent(t, "TestReportTestComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent 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.hasOperation()) {
      composeTestReportSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
    }
    if (element.hasAssert()) {
      composeTestReportSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
    }
  }

  protected void composeTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent 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, "teardown", name, element, index);
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestReportTeardownActionComponent(t, "TestReportTeardownComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent 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.hasOperation()) {
      composeTestReportSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
    }
  }

  protected void composeTestScript(Complex parent, String parentType, String name, TestScript 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, "TestScript", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "TestScript", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "TestScript", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "TestScript", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "TestScript", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "TestScript", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "TestScript", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "TestScript", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "TestScript", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "TestScript", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    for (int i = 0; i < element.getOrigin().size(); i++) {
      composeTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i);
    }
    for (int i = 0; i < element.getDestination().size(); i++) {
      composeTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i);
    }
    if (element.hasMetadata()) {
      composeTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1);
    }
    for (int i = 0; i < element.getScope().size(); i++) {
      composeTestScriptScopeComponent(t, "TestScript", "scope", element.getScope().get(i), i);
    }
    for (int i = 0; i < element.getFixture().size(); i++) {
      composeTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i);
    }
    for (int i = 0; i < element.getProfile().size(); i++) {
      composeCanonical(t, "TestScript", "profile", element.getProfile().get(i), i);
    }
    for (int i = 0; i < element.getVariable().size(); i++) {
      composeTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i);
    }
    if (element.hasSetup()) {
      composeTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1);
    }
    for (int i = 0; i < element.getTest().size(); i++) {
      composeTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i);
    }
    if (element.hasTeardown()) {
      composeTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1);
    }
  }

  protected void composeTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent 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, "origin", name, element, index);
    if (element.hasIndexElement()) {
      composeInteger(t, "TestScriptOriginComponent", "index", element.getIndexElement(), -1);
    }
    if (element.hasProfile()) {
      composeCoding(t, "TestScriptOriginComponent", "profile", element.getProfile(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "TestScriptOriginComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent 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, "destination", name, element, index);
    if (element.hasIndexElement()) {
      composeInteger(t, "TestScriptDestinationComponent", "index", element.getIndexElement(), -1);
    }
    if (element.hasProfile()) {
      composeCoding(t, "TestScriptDestinationComponent", "profile", element.getProfile(), -1);
    }
    if (element.hasUrlElement()) {
      composeUrl(t, "TestScriptDestinationComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent 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, "metadata", name, element, index);
    for (int i = 0; i < element.getLink().size(); i++) {
      composeTestScriptMetadataLinkComponent(t, "TestScriptMetadataComponent", "link", element.getLink().get(i), i);
    }
    for (int i = 0; i < element.getCapability().size(); i++) {
      composeTestScriptMetadataCapabilityComponent(t, "TestScriptMetadataComponent", "capability", element.getCapability().get(i), i);
    }
  }

  protected void composeTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent 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.hasUrlElement()) {
      composeUri(t, "TestScriptMetadataLinkComponent", "url", element.getUrlElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "TestScriptMetadataLinkComponent", "description", element.getDescriptionElement(), -1);
    }
  }

  protected void composeTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent 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, "capability", name, element, index);
    if (element.hasRequiredElement()) {
      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "required", element.getRequiredElement(), -1);
    }
    if (element.hasValidatedElement()) {
      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "validated", element.getValidatedElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "TestScriptMetadataCapabilityComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getOrigin().size(); i++) {
      composeInteger(t, "TestScriptMetadataCapabilityComponent", "origin", element.getOrigin().get(i), i);
    }
    if (element.hasDestinationElement()) {
      composeInteger(t, "TestScriptMetadataCapabilityComponent", "destination", element.getDestinationElement(), -1);
    }
    for (int i = 0; i < element.getLink().size(); i++) {
      composeUri(t, "TestScriptMetadataCapabilityComponent", "link", element.getLink().get(i), i);
    }
    if (element.hasCapabilitiesElement()) {
      composeCanonical(t, "TestScriptMetadataCapabilityComponent", "capabilities", element.getCapabilitiesElement(), -1);
    }
  }

  protected void composeTestScriptScopeComponent(Complex parent, String parentType, String name, TestScript.TestScriptScopeComponent 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, "scope", name, element, index);
    if (element.hasArtifactElement()) {
      composeCanonical(t, "TestScriptScopeComponent", "artifact", element.getArtifactElement(), -1);
    }
    if (element.hasConformance()) {
      composeCodeableConcept(t, "TestScriptScopeComponent", "conformance", element.getConformance(), -1);
    }
    if (element.hasPhase()) {
      composeCodeableConcept(t, "TestScriptScopeComponent", "phase", element.getPhase(), -1);
    }
  }

  protected void composeTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent 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, "fixture", name, element, index);
    if (element.hasAutocreateElement()) {
      composeBoolean(t, "TestScriptFixtureComponent", "autocreate", element.getAutocreateElement(), -1);
    }
    if (element.hasAutodeleteElement()) {
      composeBoolean(t, "TestScriptFixtureComponent", "autodelete", element.getAutodeleteElement(), -1);
    }
    if (element.hasResource()) {
      composeReference(t, "TestScriptFixtureComponent", "resource", element.getResource(), -1);
    }
  }

  protected void composeTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent 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, "variable", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "TestScriptVariableComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDefaultValueElement()) {
      composeString(t, "TestScriptVariableComponent", "defaultValue", element.getDefaultValueElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "TestScriptVariableComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "TestScriptVariableComponent", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasHeaderFieldElement()) {
      composeString(t, "TestScriptVariableComponent", "headerField", element.getHeaderFieldElement(), -1);
    }
    if (element.hasHintElement()) {
      composeString(t, "TestScriptVariableComponent", "hint", element.getHintElement(), -1);
    }
    if (element.hasPathElement()) {
      composeString(t, "TestScriptVariableComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasSourceIdElement()) {
      composeId(t, "TestScriptVariableComponent", "sourceId", element.getSourceIdElement(), -1);
    }
  }

  protected void composeTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent 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, "setup", name, element, index);
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestScriptSetupActionComponent(t, "TestScriptSetupComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent 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.hasOperation()) {
      composeTestScriptSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1);
    }
    if (element.hasAssert()) {
      composeTestScriptSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
    }
  }

  protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent 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.hasType()) {
      composeCoding(t, "SetupActionOperationComponent", "type", element.getType(), -1);
    }
    if (element.hasResourceElement()) {
      composeUri(t, "SetupActionOperationComponent", "resource", element.getResourceElement(), -1);
    }
    if (element.hasLabelElement()) {
      composeString(t, "SetupActionOperationComponent", "label", element.getLabelElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "SetupActionOperationComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasAcceptElement()) {
      composeCode(t, "SetupActionOperationComponent", "accept", element.getAcceptElement(), -1);
    }
    if (element.hasContentTypeElement()) {
      composeCode(t, "SetupActionOperationComponent", "contentType", element.getContentTypeElement(), -1);
    }
    if (element.hasDestinationElement()) {
      composeInteger(t, "SetupActionOperationComponent", "destination", element.getDestinationElement(), -1);
    }
    if (element.hasEncodeRequestUrlElement()) {
      composeBoolean(t, "SetupActionOperationComponent", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1);
    }
    if (element.hasMethodElement()) {
      composeEnum(t, "SetupActionOperationComponent", "method", element.getMethodElement(), -1);
    }
    if (element.hasOriginElement()) {
      composeInteger(t, "SetupActionOperationComponent", "origin", element.getOriginElement(), -1);
    }
    if (element.hasParamsElement()) {
      composeString(t, "SetupActionOperationComponent", "params", element.getParamsElement(), -1);
    }
    for (int i = 0; i < element.getRequestHeader().size(); i++) {
      composeTestScriptSetupActionOperationRequestHeaderComponent(t, "SetupActionOperationComponent", "requestHeader", element.getRequestHeader().get(i), i);
    }
    if (element.hasRequestIdElement()) {
      composeId(t, "SetupActionOperationComponent", "requestId", element.getRequestIdElement(), -1);
    }
    if (element.hasResponseIdElement()) {
      composeId(t, "SetupActionOperationComponent", "responseId", element.getResponseIdElement(), -1);
    }
    if (element.hasSourceIdElement()) {
      composeId(t, "SetupActionOperationComponent", "sourceId", element.getSourceIdElement(), -1);
    }
    if (element.hasTargetIdElement()) {
      composeId(t, "SetupActionOperationComponent", "targetId", element.getTargetIdElement(), -1);
    }
    if (element.hasUrlElement()) {
      composeString(t, "SetupActionOperationComponent", "url", element.getUrlElement(), -1);
    }
  }

  protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent 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, "requestHeader", name, element, index);
    if (element.hasFieldElement()) {
      composeString(t, "SetupActionOperationRequestHeaderComponent", "field", element.getFieldElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "SetupActionOperationRequestHeaderComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent 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, "assert", name, element, index);
    if (element.hasLabelElement()) {
      composeString(t, "SetupActionAssertComponent", "label", element.getLabelElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "SetupActionAssertComponent", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasDirectionElement()) {
      composeEnum(t, "SetupActionAssertComponent", "direction", element.getDirectionElement(), -1);
    }
    if (element.hasCompareToSourceIdElement()) {
      composeString(t, "SetupActionAssertComponent", "compareToSourceId", element.getCompareToSourceIdElement(), -1);
    }
    if (element.hasCompareToSourceExpressionElement()) {
      composeString(t, "SetupActionAssertComponent", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1);
    }
    if (element.hasCompareToSourcePathElement()) {
      composeString(t, "SetupActionAssertComponent", "compareToSourcePath", element.getCompareToSourcePathElement(), -1);
    }
    if (element.hasContentTypeElement()) {
      composeCode(t, "SetupActionAssertComponent", "contentType", element.getContentTypeElement(), -1);
    }
    if (element.hasDefaultManualCompletionElement()) {
      composeEnum(t, "SetupActionAssertComponent", "defaultManualCompletion", element.getDefaultManualCompletionElement(), -1);
    }
    if (element.hasExpressionElement()) {
      composeString(t, "SetupActionAssertComponent", "expression", element.getExpressionElement(), -1);
    }
    if (element.hasHeaderFieldElement()) {
      composeString(t, "SetupActionAssertComponent", "headerField", element.getHeaderFieldElement(), -1);
    }
    if (element.hasMinimumIdElement()) {
      composeString(t, "SetupActionAssertComponent", "minimumId", element.getMinimumIdElement(), -1);
    }
    if (element.hasNavigationLinksElement()) {
      composeBoolean(t, "SetupActionAssertComponent", "navigationLinks", element.getNavigationLinksElement(), -1);
    }
    if (element.hasOperatorElement()) {
      composeEnum(t, "SetupActionAssertComponent", "operator", element.getOperatorElement(), -1);
    }
    if (element.hasPathElement()) {
      composeString(t, "SetupActionAssertComponent", "path", element.getPathElement(), -1);
    }
    if (element.hasRequestMethodElement()) {
      composeEnum(t, "SetupActionAssertComponent", "requestMethod", element.getRequestMethodElement(), -1);
    }
    if (element.hasRequestURLElement()) {
      composeString(t, "SetupActionAssertComponent", "requestURL", element.getRequestURLElement(), -1);
    }
    if (element.hasResourceElement()) {
      composeUri(t, "SetupActionAssertComponent", "resource", element.getResourceElement(), -1);
    }
    if (element.hasResponseElement()) {
      composeEnum(t, "SetupActionAssertComponent", "response", element.getResponseElement(), -1);
    }
    if (element.hasResponseCodeElement()) {
      composeString(t, "SetupActionAssertComponent", "responseCode", element.getResponseCodeElement(), -1);
    }
    if (element.hasSourceIdElement()) {
      composeId(t, "SetupActionAssertComponent", "sourceId", element.getSourceIdElement(), -1);
    }
    if (element.hasStopTestOnFailElement()) {
      composeBoolean(t, "SetupActionAssertComponent", "stopTestOnFail", element.getStopTestOnFailElement(), -1);
    }
    if (element.hasValidateProfileIdElement()) {
      composeId(t, "SetupActionAssertComponent", "validateProfileId", element.getValidateProfileIdElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "SetupActionAssertComponent", "value", element.getValueElement(), -1);
    }
    if (element.hasWarningOnlyElement()) {
      composeBoolean(t, "SetupActionAssertComponent", "warningOnly", element.getWarningOnlyElement(), -1);
    }
    for (int i = 0; i < element.getRequirement().size(); i++) {
      composeTestScriptSetupActionAssertRequirementComponent(t, "SetupActionAssertComponent", "requirement", element.getRequirement().get(i), i);
    }
  }

  protected void composeTestScriptSetupActionAssertRequirementComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRequirementComponent 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, "requirement", name, element, index);
    if (element.hasLink()) {
      composeType(t, "SetupActionAssertRequirementComponent", "link", element.getLink(), -1);
    }
  }

  protected void composeTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent 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, "test", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "TestScriptTestComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "TestScriptTestComponent", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestScriptTestActionComponent(t, "TestScriptTestComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent 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.hasOperation()) {
      composeTestScriptSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
    }
    if (element.hasAssert()) {
      composeTestScriptSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
    }
  }

  protected void composeTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent 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, "teardown", name, element, index);
    for (int i = 0; i < element.getAction().size(); i++) {
      composeTestScriptTeardownActionComponent(t, "TestScriptTeardownComponent", "action", element.getAction().get(i), i);
    }
  }

  protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent 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.hasOperation()) {
      composeTestScriptSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
    }
  }

  protected void composeTransport(Complex parent, String parentType, String name, Transport 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, "Transport", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "Transport", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasInstantiatesCanonicalElement()) {
      composeCanonical(t, "Transport", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
    }
    if (element.hasInstantiatesUriElement()) {
      composeUri(t, "Transport", "instantiatesUri", element.getInstantiatesUriElement(), -1);
    }
    for (int i = 0; i < element.getBasedOn().size(); i++) {
      composeReference(t, "Transport", "basedOn", element.getBasedOn().get(i), i);
    }
    if (element.hasGroupIdentifier()) {
      composeIdentifier(t, "Transport", "groupIdentifier", element.getGroupIdentifier(), -1);
    }
    for (int i = 0; i < element.getPartOf().size(); i++) {
      composeReference(t, "Transport", "partOf", element.getPartOf().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "Transport", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusReason()) {
      composeCodeableConcept(t, "Transport", "statusReason", element.getStatusReason(), -1);
    }
    if (element.hasIntentElement()) {
      composeEnum(t, "Transport", "intent", element.getIntentElement(), -1);
    }
    if (element.hasPriorityElement()) {
      composeEnum(t, "Transport", "priority", element.getPriorityElement(), -1);
    }
    if (element.hasCode()) {
      composeCodeableConcept(t, "Transport", "code", element.getCode(), -1);
    }
    if (element.hasDescriptionElement()) {
      composeString(t, "Transport", "description", element.getDescriptionElement(), -1);
    }
    if (element.hasFocus()) {
      composeReference(t, "Transport", "focus", element.getFocus(), -1);
    }
    if (element.hasFor()) {
      composeReference(t, "Transport", "for", element.getFor(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "Transport", "encounter", element.getEncounter(), -1);
    }
    if (element.hasCompletionTimeElement()) {
      composeDateTime(t, "Transport", "completionTime", element.getCompletionTimeElement(), -1);
    }
    if (element.hasAuthoredOnElement()) {
      composeDateTime(t, "Transport", "authoredOn", element.getAuthoredOnElement(), -1);
    }
    if (element.hasLastModifiedElement()) {
      composeDateTime(t, "Transport", "lastModified", element.getLastModifiedElement(), -1);
    }
    if (element.hasRequester()) {
      composeReference(t, "Transport", "requester", element.getRequester(), -1);
    }
    for (int i = 0; i < element.getPerformerType().size(); i++) {
      composeCodeableConcept(t, "Transport", "performerType", element.getPerformerType().get(i), i);
    }
    if (element.hasOwner()) {
      composeReference(t, "Transport", "owner", element.getOwner(), -1);
    }
    if (element.hasLocation()) {
      composeReference(t, "Transport", "location", element.getLocation(), -1);
    }
    for (int i = 0; i < element.getInsurance().size(); i++) {
      composeReference(t, "Transport", "insurance", element.getInsurance().get(i), i);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "Transport", "note", element.getNote().get(i), i);
    }
    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
      composeReference(t, "Transport", "relevantHistory", element.getRelevantHistory().get(i), i);
    }
    if (element.hasRestriction()) {
      composeTransportRestrictionComponent(t, "Transport", "restriction", element.getRestriction(), -1);
    }
    for (int i = 0; i < element.getInput().size(); i++) {
      composeTransportParameterComponent(t, "Transport", "input", element.getInput().get(i), i);
    }
    for (int i = 0; i < element.getOutput().size(); i++) {
      composeTransportOutputComponent(t, "Transport", "output", element.getOutput().get(i), i);
    }
    if (element.hasRequestedLocation()) {
      composeReference(t, "Transport", "requestedLocation", element.getRequestedLocation(), -1);
    }
    if (element.hasCurrentLocation()) {
      composeReference(t, "Transport", "currentLocation", element.getCurrentLocation(), -1);
    }
    if (element.hasReason()) {
      composeCodeableReference(t, "Transport", "reason", element.getReason(), -1);
    }
    if (element.hasHistory()) {
      composeReference(t, "Transport", "history", element.getHistory(), -1);
    }
  }

  protected void composeTransportRestrictionComponent(Complex parent, String parentType, String name, Transport.TransportRestrictionComponent 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, "restriction", name, element, index);
    if (element.hasRepetitionsElement()) {
      composePositiveInt(t, "TransportRestrictionComponent", "repetitions", element.getRepetitionsElement(), -1);
    }
    if (element.hasPeriod()) {
      composePeriod(t, "TransportRestrictionComponent", "period", element.getPeriod(), -1);
    }
    for (int i = 0; i < element.getRecipient().size(); i++) {
      composeReference(t, "TransportRestrictionComponent", "recipient", element.getRecipient().get(i), i);
    }
  }

  protected void composeTransportParameterComponent(Complex parent, String parentType, String name, Transport.ParameterComponent 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, "input", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "ParameterComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeTransportOutputComponent(Complex parent, String parentType, String name, Transport.TransportOutputComponent 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, "output", name, element, index);
    if (element.hasType()) {
      composeCodeableConcept(t, "TransportOutputComponent", "type", element.getType(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "TransportOutputComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeValueSet(Complex parent, String parentType, String name, ValueSet 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, "ValueSet", name, element, index);
    if (element.hasUrlElement()) {
      composeUri(t, "ValueSet", "url", element.getUrlElement(), -1);
    }
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ValueSet", "version", element.getVersionElement(), -1);
    }
    if (element.hasVersionAlgorithm()) {
      composeType(t, "ValueSet", "versionAlgorithm", element.getVersionAlgorithm(), -1);
    }
    if (element.hasNameElement()) {
      composeString(t, "ValueSet", "name", element.getNameElement(), -1);
    }
    if (element.hasTitleElement()) {
      composeString(t, "ValueSet", "title", element.getTitleElement(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1);
    }
    if (element.hasExperimentalElement()) {
      composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1);
    }
    if (element.hasDateElement()) {
      composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1);
    }
    if (element.hasPublisherElement()) {
      composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1);
    }
    for (int i = 0; i < element.getContact().size(); i++) {
      composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i);
    }
    if (element.hasDescriptionElement()) {
      composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1);
    }
    for (int i = 0; i < element.getUseContext().size(); i++) {
      composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i);
    }
    for (int i = 0; i < element.getJurisdiction().size(); i++) {
      composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i);
    }
    if (element.hasImmutableElement()) {
      composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1);
    }
    if (element.hasPurposeElement()) {
      composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1);
    }
    if (element.hasCopyrightElement()) {
      composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1);
    }
    if (element.hasCopyrightLabelElement()) {
      composeString(t, "ValueSet", "copyrightLabel", element.getCopyrightLabelElement(), -1);
    }
    if (element.hasApprovalDateElement()) {
      composeDate(t, "ValueSet", "approvalDate", element.getApprovalDateElement(), -1);
    }
    if (element.hasLastReviewDateElement()) {
      composeDate(t, "ValueSet", "lastReviewDate", element.getLastReviewDateElement(), -1);
    }
    if (element.hasEffectivePeriod()) {
      composePeriod(t, "ValueSet", "effectivePeriod", element.getEffectivePeriod(), -1);
    }
    for (int i = 0; i < element.getTopic().size(); i++) {
      composeCodeableConcept(t, "ValueSet", "topic", element.getTopic().get(i), i);
    }
    for (int i = 0; i < element.getAuthor().size(); i++) {
      composeContactDetail(t, "ValueSet", "author", element.getAuthor().get(i), i);
    }
    for (int i = 0; i < element.getEditor().size(); i++) {
      composeContactDetail(t, "ValueSet", "editor", element.getEditor().get(i), i);
    }
    for (int i = 0; i < element.getReviewer().size(); i++) {
      composeContactDetail(t, "ValueSet", "reviewer", element.getReviewer().get(i), i);
    }
    for (int i = 0; i < element.getEndorser().size(); i++) {
      composeContactDetail(t, "ValueSet", "endorser", element.getEndorser().get(i), i);
    }
    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
      composeRelatedArtifact(t, "ValueSet", "relatedArtifact", element.getRelatedArtifact().get(i), i);
    }
    if (element.hasCompose()) {
      composeValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1);
    }
    if (element.hasExpansion()) {
      composeValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1);
    }
    if (element.hasScope()) {
      composeValueSetScopeComponent(t, "ValueSet", "scope", element.getScope(), -1);
    }
  }

  protected void composeValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent 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, "compose", name, element, index);
    if (element.hasLockedDateElement()) {
      composeDate(t, "ValueSetComposeComponent", "lockedDate", element.getLockedDateElement(), -1);
    }
    if (element.hasInactiveElement()) {
      composeBoolean(t, "ValueSetComposeComponent", "inactive", element.getInactiveElement(), -1);
    }
    for (int i = 0; i < element.getInclude().size(); i++) {
      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "include", element.getInclude().get(i), i);
    }
    for (int i = 0; i < element.getExclude().size(); i++) {
      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "exclude", element.getExclude().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeString(t, "ValueSetComposeComponent", "property", element.getProperty().get(i), i);
    }
  }

  protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent 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, "include", name, element, index);
    if (element.hasSystemElement()) {
      composeUri(t, "ConceptSetComponent", "system", element.getSystemElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ConceptSetComponent", "version", element.getVersionElement(), -1);
    }
    for (int i = 0; i < element.getConcept().size(); i++) {
      composeValueSetConceptReferenceComponent(t, "ConceptSetComponent", "concept", element.getConcept().get(i), i);
    }
    for (int i = 0; i < element.getFilter().size(); i++) {
      composeValueSetConceptSetFilterComponent(t, "ConceptSetComponent", "filter", element.getFilter().get(i), i);
    }
    for (int i = 0; i < element.getValueSet().size(); i++) {
      composeCanonical(t, "ConceptSetComponent", "valueSet", element.getValueSet().get(i), i);
    }
    if (element.hasCopyrightElement()) {
      composeString(t, "ConceptSetComponent", "copyright", element.getCopyrightElement(), -1);
    }
  }

  protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent 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, "ConceptReferenceComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "ConceptReferenceComponent", "display", element.getDisplayElement(), -1);
    }
    for (int i = 0; i < element.getDesignation().size(); i++) {
      composeValueSetConceptReferenceDesignationComponent(t, "ConceptReferenceComponent", "designation", element.getDesignation().get(i), i);
    }
  }

  protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent 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, "ConceptReferenceDesignationComponent", "language", element.getLanguageElement(), -1);
    }
    if (element.hasUse()) {
      composeCoding(t, "ConceptReferenceDesignationComponent", "use", element.getUse(), -1);
    }
    for (int i = 0; i < element.getAdditionalUse().size(); i++) {
      composeCoding(t, "ConceptReferenceDesignationComponent", "additionalUse", element.getAdditionalUse().get(i), i);
    }
    if (element.hasValueElement()) {
      composeString(t, "ConceptReferenceDesignationComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent 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.hasPropertyElement()) {
      composeCode(t, "ConceptSetFilterComponent", "property", element.getPropertyElement(), -1);
    }
    if (element.hasOpElement()) {
      composeEnum(t, "ConceptSetFilterComponent", "op", element.getOpElement(), -1);
    }
    if (element.hasValueElement()) {
      composeString(t, "ConceptSetFilterComponent", "value", element.getValueElement(), -1);
    }
  }

  protected void composeValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent 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, "expansion", name, element, index);
    if (element.hasIdentifierElement()) {
      composeUri(t, "ValueSetExpansionComponent", "identifier", element.getIdentifierElement(), -1);
    }
    if (element.hasNextElement()) {
      composeUri(t, "ValueSetExpansionComponent", "next", element.getNextElement(), -1);
    }
    if (element.hasTimestampElement()) {
      composeDateTime(t, "ValueSetExpansionComponent", "timestamp", element.getTimestampElement(), -1);
    }
    if (element.hasTotalElement()) {
      composeInteger(t, "ValueSetExpansionComponent", "total", element.getTotalElement(), -1);
    }
    if (element.hasOffsetElement()) {
      composeInteger(t, "ValueSetExpansionComponent", "offset", element.getOffsetElement(), -1);
    }
    for (int i = 0; i < element.getParameter().size(); i++) {
      composeValueSetExpansionParameterComponent(t, "ValueSetExpansionComponent", "parameter", element.getParameter().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeValueSetExpansionPropertyComponent(t, "ValueSetExpansionComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getContains().size(); i++) {
      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionComponent", "contains", element.getContains().get(i), i);
    }
  }

  protected void composeValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent 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, "parameter", name, element, index);
    if (element.hasNameElement()) {
      composeString(t, "ValueSetExpansionParameterComponent", "name", element.getNameElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ValueSetExpansionParameterComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeValueSetExpansionPropertyComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionPropertyComponent 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, "ValueSetExpansionPropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasUriElement()) {
      composeUri(t, "ValueSetExpansionPropertyComponent", "uri", element.getUriElement(), -1);
    }
  }

  protected void composeValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent 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, "contains", name, element, index);
    if (element.hasSystemElement()) {
      composeUri(t, "ValueSetExpansionContainsComponent", "system", element.getSystemElement(), -1);
    }
    if (element.hasAbstractElement()) {
      composeBoolean(t, "ValueSetExpansionContainsComponent", "abstract", element.getAbstractElement(), -1);
    }
    if (element.hasInactiveElement()) {
      composeBoolean(t, "ValueSetExpansionContainsComponent", "inactive", element.getInactiveElement(), -1);
    }
    if (element.hasVersionElement()) {
      composeString(t, "ValueSetExpansionContainsComponent", "version", element.getVersionElement(), -1);
    }
    if (element.hasCodeElement()) {
      composeCode(t, "ValueSetExpansionContainsComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasDisplayElement()) {
      composeString(t, "ValueSetExpansionContainsComponent", "display", element.getDisplayElement(), -1);
    }
    for (int i = 0; i < element.getDesignation().size(); i++) {
      composeValueSetConceptReferenceDesignationComponent(t, "ValueSetExpansionContainsComponent", "designation", element.getDesignation().get(i), i);
    }
    for (int i = 0; i < element.getProperty().size(); i++) {
      composeValueSetConceptPropertyComponent(t, "ValueSetExpansionContainsComponent", "property", element.getProperty().get(i), i);
    }
    for (int i = 0; i < element.getContains().size(); i++) {
      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionContainsComponent", "contains", element.getContains().get(i), i);
    }
  }

  protected void composeValueSetConceptPropertyComponent(Complex parent, String parentType, String name, ValueSet.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);
    }
    for (int i = 0; i < element.getSubProperty().size(); i++) {
      composeValueSetConceptSubPropertyComponent(t, "ConceptPropertyComponent", "subProperty", element.getSubProperty().get(i), i);
    }
  }

  protected void composeValueSetConceptSubPropertyComponent(Complex parent, String parentType, String name, ValueSet.ConceptSubPropertyComponent 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, "subProperty", name, element, index);
    if (element.hasCodeElement()) {
      composeCode(t, "ConceptSubPropertyComponent", "code", element.getCodeElement(), -1);
    }
    if (element.hasValue()) {
      composeType(t, "ConceptSubPropertyComponent", "value", element.getValue(), -1);
    }
  }

  protected void composeValueSetScopeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetScopeComponent 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, "scope", name, element, index);
    if (element.hasInclusionCriteriaElement()) {
      composeString(t, "ValueSetScopeComponent", "inclusionCriteria", element.getInclusionCriteriaElement(), -1);
    }
    if (element.hasExclusionCriteriaElement()) {
      composeString(t, "ValueSetScopeComponent", "exclusionCriteria", element.getExclusionCriteriaElement(), -1);
    }
  }

  protected void composeVerificationResult(Complex parent, String parentType, String name, VerificationResult 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, "VerificationResult", name, element, index);
    for (int i = 0; i < element.getTarget().size(); i++) {
      composeReference(t, "VerificationResult", "target", element.getTarget().get(i), i);
    }
    for (int i = 0; i < element.getTargetLocation().size(); i++) {
      composeString(t, "VerificationResult", "targetLocation", element.getTargetLocation().get(i), i);
    }
    if (element.hasNeed()) {
      composeCodeableConcept(t, "VerificationResult", "need", element.getNeed(), -1);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "VerificationResult", "status", element.getStatusElement(), -1);
    }
    if (element.hasStatusDateElement()) {
      composeDateTime(t, "VerificationResult", "statusDate", element.getStatusDateElement(), -1);
    }
    if (element.hasValidationType()) {
      composeCodeableConcept(t, "VerificationResult", "validationType", element.getValidationType(), -1);
    }
    for (int i = 0; i < element.getValidationProcess().size(); i++) {
      composeCodeableConcept(t, "VerificationResult", "validationProcess", element.getValidationProcess().get(i), i);
    }
    if (element.hasFrequency()) {
      composeTiming(t, "VerificationResult", "frequency", element.getFrequency(), -1);
    }
    if (element.hasLastPerformedElement()) {
      composeDateTime(t, "VerificationResult", "lastPerformed", element.getLastPerformedElement(), -1);
    }
    if (element.hasNextScheduledElement()) {
      composeDate(t, "VerificationResult", "nextScheduled", element.getNextScheduledElement(), -1);
    }
    if (element.hasFailureAction()) {
      composeCodeableConcept(t, "VerificationResult", "failureAction", element.getFailureAction(), -1);
    }
    for (int i = 0; i < element.getPrimarySource().size(); i++) {
      composeVerificationResultPrimarySourceComponent(t, "VerificationResult", "primarySource", element.getPrimarySource().get(i), i);
    }
    if (element.hasAttestation()) {
      composeVerificationResultAttestationComponent(t, "VerificationResult", "attestation", element.getAttestation(), -1);
    }
    for (int i = 0; i < element.getValidator().size(); i++) {
      composeVerificationResultValidatorComponent(t, "VerificationResult", "validator", element.getValidator().get(i), i);
    }
  }

  protected void composeVerificationResultPrimarySourceComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultPrimarySourceComponent 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, "primarySource", name, element, index);
    if (element.hasWho()) {
      composeReference(t, "VerificationResultPrimarySourceComponent", "who", element.getWho(), -1);
    }
    for (int i = 0; i < element.getType().size(); i++) {
      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "type", element.getType().get(i), i);
    }
    for (int i = 0; i < element.getCommunicationMethod().size(); i++) {
      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "communicationMethod", element.getCommunicationMethod().get(i), i);
    }
    if (element.hasValidationStatus()) {
      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "validationStatus", element.getValidationStatus(), -1);
    }
    if (element.hasValidationDateElement()) {
      composeDateTime(t, "VerificationResultPrimarySourceComponent", "validationDate", element.getValidationDateElement(), -1);
    }
    if (element.hasCanPushUpdates()) {
      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "canPushUpdates", element.getCanPushUpdates(), -1);
    }
    for (int i = 0; i < element.getPushTypeAvailable().size(); i++) {
      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "pushTypeAvailable", element.getPushTypeAvailable().get(i), i);
    }
  }

  protected void composeVerificationResultAttestationComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultAttestationComponent 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, "attestation", name, element, index);
    if (element.hasWho()) {
      composeReference(t, "VerificationResultAttestationComponent", "who", element.getWho(), -1);
    }
    if (element.hasOnBehalfOf()) {
      composeReference(t, "VerificationResultAttestationComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
    }
    if (element.hasCommunicationMethod()) {
      composeCodeableConcept(t, "VerificationResultAttestationComponent", "communicationMethod", element.getCommunicationMethod(), -1);
    }
    if (element.hasDateElement()) {
      composeDate(t, "VerificationResultAttestationComponent", "date", element.getDateElement(), -1);
    }
    if (element.hasSourceIdentityCertificateElement()) {
      composeString(t, "VerificationResultAttestationComponent", "sourceIdentityCertificate", element.getSourceIdentityCertificateElement(), -1);
    }
    if (element.hasProxyIdentityCertificateElement()) {
      composeString(t, "VerificationResultAttestationComponent", "proxyIdentityCertificate", element.getProxyIdentityCertificateElement(), -1);
    }
    if (element.hasProxySignature()) {
      composeSignature(t, "VerificationResultAttestationComponent", "proxySignature", element.getProxySignature(), -1);
    }
    if (element.hasSourceSignature()) {
      composeSignature(t, "VerificationResultAttestationComponent", "sourceSignature", element.getSourceSignature(), -1);
    }
  }

  protected void composeVerificationResultValidatorComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultValidatorComponent 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, "validator", name, element, index);
    if (element.hasOrganization()) {
      composeReference(t, "VerificationResultValidatorComponent", "organization", element.getOrganization(), -1);
    }
    if (element.hasIdentityCertificateElement()) {
      composeString(t, "VerificationResultValidatorComponent", "identityCertificate", element.getIdentityCertificateElement(), -1);
    }
    if (element.hasAttestationSignature()) {
      composeSignature(t, "VerificationResultValidatorComponent", "attestationSignature", element.getAttestationSignature(), -1);
    }
  }

  protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription 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, "VisionPrescription", name, element, index);
    for (int i = 0; i < element.getIdentifier().size(); i++) {
      composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i);
    }
    if (element.hasStatusElement()) {
      composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1);
    }
    if (element.hasCreatedElement()) {
      composeDateTime(t, "VisionPrescription", "created", element.getCreatedElement(), -1);
    }
    if (element.hasPatient()) {
      composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1);
    }
    if (element.hasEncounter()) {
      composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1);
    }
    if (element.hasDateWrittenElement()) {
      composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1);
    }
    if (element.hasPrescriber()) {
      composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1);
    }
    for (int i = 0; i < element.getLensSpecification().size(); i++) {
      composeVisionPrescriptionLensSpecificationComponent(t, "VisionPrescription", "lensSpecification", element.getLensSpecification().get(i), i);
    }
  }

  protected void composeVisionPrescriptionLensSpecificationComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionLensSpecificationComponent 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, "lensSpecification", name, element, index);
    if (element.hasProduct()) {
      composeCodeableConcept(t, "VisionPrescriptionLensSpecificationComponent", "product", element.getProduct(), -1);
    }
    if (element.hasEyeElement()) {
      composeEnum(t, "VisionPrescriptionLensSpecificationComponent", "eye", element.getEyeElement(), -1);
    }
    if (element.hasSphereElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "sphere", element.getSphereElement(), -1);
    }
    if (element.hasCylinderElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "cylinder", element.getCylinderElement(), -1);
    }
    if (element.hasAxisElement()) {
      composeInteger(t, "VisionPrescriptionLensSpecificationComponent", "axis", element.getAxisElement(), -1);
    }
    for (int i = 0; i < element.getPrism().size(); i++) {
      composeVisionPrescriptionPrismComponent(t, "VisionPrescriptionLensSpecificationComponent", "prism", element.getPrism().get(i), i);
    }
    if (element.hasAddElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "add", element.getAddElement(), -1);
    }
    if (element.hasPowerElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "power", element.getPowerElement(), -1);
    }
    if (element.hasBackCurveElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "backCurve", element.getBackCurveElement(), -1);
    }
    if (element.hasDiameterElement()) {
      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "diameter", element.getDiameterElement(), -1);
    }
    if (element.hasDuration()) {
      composeQuantity(t, "VisionPrescriptionLensSpecificationComponent", "duration", element.getDuration(), -1);
    }
    if (element.hasColorElement()) {
      composeString(t, "VisionPrescriptionLensSpecificationComponent", "color", element.getColorElement(), -1);
    }
    if (element.hasBrandElement()) {
      composeString(t, "VisionPrescriptionLensSpecificationComponent", "brand", element.getBrandElement(), -1);
    }
    for (int i = 0; i < element.getNote().size(); i++) {
      composeAnnotation(t, "VisionPrescriptionLensSpecificationComponent", "note", element.getNote().get(i), i);
    }
  }

  protected void composeVisionPrescriptionPrismComponent(Complex parent, String parentType, String name, VisionPrescription.PrismComponent 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, "prism", name, element, index);
    if (element.hasAmountElement()) {
      composeDecimal(t, "PrismComponent", "amount", element.getAmountElement(), -1);
    }
    if (element.hasBaseElement()) {
      composeEnum(t, "PrismComponent", "base", element.getBaseElement(), -1);
    }
  }




  @Override
  protected void composeResource(Complex parent, Resource resource) {
    if (parent == null) {
      throw new Error("parent == null");
    } else if (resource == null) {
      throw new Error("resource == null");
    } else if (resource instanceof Account) {
      composeAccount(parent, null, "Account", (Account)resource, -1);
    } else if (resource instanceof ActivityDefinition) {
      composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1);
    } else if (resource instanceof ActorDefinition) {
      composeActorDefinition(parent, null, "ActorDefinition", (ActorDefinition)resource, -1);
    } else if (resource instanceof AdministrableProductDefinition) {
      composeAdministrableProductDefinition(parent, null, "AdministrableProductDefinition", (AdministrableProductDefinition)resource, -1);
    } else if (resource instanceof AdverseEvent) {
      composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1);
    } else if (resource instanceof AllergyIntolerance) {
      composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1);
    } else if (resource instanceof Appointment) {
      composeAppointment(parent, null, "Appointment", (Appointment)resource, -1);
    } else if (resource instanceof AppointmentResponse) {
      composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1);
    } else if (resource instanceof ArtifactAssessment) {
      composeArtifactAssessment(parent, null, "ArtifactAssessment", (ArtifactAssessment)resource, -1);
    } else if (resource instanceof AuditEvent) {
      composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1);
    } else if (resource instanceof Basic) {
      composeBasic(parent, null, "Basic", (Basic)resource, -1);
    } else if (resource instanceof Binary) {
      composeBinary(parent, null, "Binary", (Binary)resource, -1);
    } else if (resource instanceof BiologicallyDerivedProduct) {
      composeBiologicallyDerivedProduct(parent, null, "BiologicallyDerivedProduct", (BiologicallyDerivedProduct)resource, -1);
    } else if (resource instanceof BiologicallyDerivedProductDispense) {
      composeBiologicallyDerivedProductDispense(parent, null, "BiologicallyDerivedProductDispense", (BiologicallyDerivedProductDispense)resource, -1);
    } else if (resource instanceof BodyStructure) {
      composeBodyStructure(parent, null, "BodyStructure", (BodyStructure)resource, -1);
    } else if (resource instanceof Bundle) {
      composeBundle(parent, null, "Bundle", (Bundle)resource, -1);
    } else if (resource instanceof CapabilityStatement) {
      composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1);
    } else if (resource instanceof CarePlan) {
      composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1);
    } else if (resource instanceof CareTeam) {
      composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1);
    } else if (resource instanceof ChargeItem) {
      composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1);
    } else if (resource instanceof ChargeItemDefinition) {
      composeChargeItemDefinition(parent, null, "ChargeItemDefinition", (ChargeItemDefinition)resource, -1);
    } else if (resource instanceof Citation) {
      composeCitation(parent, null, "Citation", (Citation)resource, -1);
    } else if (resource instanceof Claim) {
      composeClaim(parent, null, "Claim", (Claim)resource, -1);
    } else if (resource instanceof ClaimResponse) {
      composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1);
    } else if (resource instanceof ClinicalImpression) {
      composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1);
    } else if (resource instanceof ClinicalUseDefinition) {
      composeClinicalUseDefinition(parent, null, "ClinicalUseDefinition", (ClinicalUseDefinition)resource, -1);
    } else if (resource instanceof CodeSystem) {
      composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1);
    } else if (resource instanceof Communication) {
      composeCommunication(parent, null, "Communication", (Communication)resource, -1);
    } else if (resource instanceof CommunicationRequest) {
      composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1);
    } else if (resource instanceof CompartmentDefinition) {
      composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1);
    } else if (resource instanceof Composition) {
      composeComposition(parent, null, "Composition", (Composition)resource, -1);
    } else if (resource instanceof ConceptMap) {
      composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1);
    } else if (resource instanceof Condition) {
      composeCondition(parent, null, "Condition", (Condition)resource, -1);
    } else if (resource instanceof ConditionDefinition) {
      composeConditionDefinition(parent, null, "ConditionDefinition", (ConditionDefinition)resource, -1);
    } else if (resource instanceof Consent) {
      composeConsent(parent, null, "Consent", (Consent)resource, -1);
    } else if (resource instanceof Contract) {
      composeContract(parent, null, "Contract", (Contract)resource, -1);
    } else if (resource instanceof Coverage) {
      composeCoverage(parent, null, "Coverage", (Coverage)resource, -1);
    } else if (resource instanceof CoverageEligibilityRequest) {
      composeCoverageEligibilityRequest(parent, null, "CoverageEligibilityRequest", (CoverageEligibilityRequest)resource, -1);
    } else if (resource instanceof CoverageEligibilityResponse) {
      composeCoverageEligibilityResponse(parent, null, "CoverageEligibilityResponse", (CoverageEligibilityResponse)resource, -1);
    } else if (resource instanceof DetectedIssue) {
      composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1);
    } else if (resource instanceof Device) {
      composeDevice(parent, null, "Device", (Device)resource, -1);
    } else if (resource instanceof DeviceAssociation) {
      composeDeviceAssociation(parent, null, "DeviceAssociation", (DeviceAssociation)resource, -1);
    } else if (resource instanceof DeviceDefinition) {
      composeDeviceDefinition(parent, null, "DeviceDefinition", (DeviceDefinition)resource, -1);
    } else if (resource instanceof DeviceDispense) {
      composeDeviceDispense(parent, null, "DeviceDispense", (DeviceDispense)resource, -1);
    } else if (resource instanceof DeviceMetric) {
      composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1);
    } else if (resource instanceof DeviceRequest) {
      composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1);
    } else if (resource instanceof DeviceUsage) {
      composeDeviceUsage(parent, null, "DeviceUsage", (DeviceUsage)resource, -1);
    } else if (resource instanceof DiagnosticReport) {
      composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1);
    } else if (resource instanceof DocumentReference) {
      composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1);
    } else if (resource instanceof Encounter) {
      composeEncounter(parent, null, "Encounter", (Encounter)resource, -1);
    } else if (resource instanceof EncounterHistory) {
      composeEncounterHistory(parent, null, "EncounterHistory", (EncounterHistory)resource, -1);
    } else if (resource instanceof Endpoint) {
      composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1);
    } else if (resource instanceof EnrollmentRequest) {
      composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1);
    } else if (resource instanceof EnrollmentResponse) {
      composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1);
    } else if (resource instanceof EpisodeOfCare) {
      composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1);
    } else if (resource instanceof EventDefinition) {
      composeEventDefinition(parent, null, "EventDefinition", (EventDefinition)resource, -1);
    } else if (resource instanceof Evidence) {
      composeEvidence(parent, null, "Evidence", (Evidence)resource, -1);
    } else if (resource instanceof EvidenceReport) {
      composeEvidenceReport(parent, null, "EvidenceReport", (EvidenceReport)resource, -1);
    } else if (resource instanceof EvidenceVariable) {
      composeEvidenceVariable(parent, null, "EvidenceVariable", (EvidenceVariable)resource, -1);
    } else if (resource instanceof ExampleScenario) {
      composeExampleScenario(parent, null, "ExampleScenario", (ExampleScenario)resource, -1);
    } else if (resource instanceof ExplanationOfBenefit) {
      composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1);
    } else if (resource instanceof FamilyMemberHistory) {
      composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1);
    } else if (resource instanceof Flag) {
      composeFlag(parent, null, "Flag", (Flag)resource, -1);
    } else if (resource instanceof FormularyItem) {
      composeFormularyItem(parent, null, "FormularyItem", (FormularyItem)resource, -1);
    } else if (resource instanceof GenomicStudy) {
      composeGenomicStudy(parent, null, "GenomicStudy", (GenomicStudy)resource, -1);
    } else if (resource instanceof Goal) {
      composeGoal(parent, null, "Goal", (Goal)resource, -1);
    } else if (resource instanceof GraphDefinition) {
      composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1);
    } else if (resource instanceof Group) {
      composeGroup(parent, null, "Group", (Group)resource, -1);
    } else if (resource instanceof GuidanceResponse) {
      composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1);
    } else if (resource instanceof HealthcareService) {
      composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1);
    } else if (resource instanceof ImagingSelection) {
      composeImagingSelection(parent, null, "ImagingSelection", (ImagingSelection)resource, -1);
    } else if (resource instanceof ImagingStudy) {
      composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1);
    } else if (resource instanceof Immunization) {
      composeImmunization(parent, null, "Immunization", (Immunization)resource, -1);
    } else if (resource instanceof ImmunizationEvaluation) {
      composeImmunizationEvaluation(parent, null, "ImmunizationEvaluation", (ImmunizationEvaluation)resource, -1);
    } else if (resource instanceof ImmunizationRecommendation) {
      composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1);
    } else if (resource instanceof ImplementationGuide) {
      composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1);
    } else if (resource instanceof Ingredient) {
      composeIngredient(parent, null, "Ingredient", (Ingredient)resource, -1);
    } else if (resource instanceof InsurancePlan) {
      composeInsurancePlan(parent, null, "InsurancePlan", (InsurancePlan)resource, -1);
    } else if (resource instanceof InventoryItem) {
      composeInventoryItem(parent, null, "InventoryItem", (InventoryItem)resource, -1);
    } else if (resource instanceof InventoryReport) {
      composeInventoryReport(parent, null, "InventoryReport", (InventoryReport)resource, -1);
    } else if (resource instanceof Invoice) {
      composeInvoice(parent, null, "Invoice", (Invoice)resource, -1);
    } else if (resource instanceof Library) {
      composeLibrary(parent, null, "Library", (Library)resource, -1);
    } else if (resource instanceof Linkage) {
      composeLinkage(parent, null, "Linkage", (Linkage)resource, -1);
    } else if (resource instanceof ListResource) {
      composeListResource(parent, null, "List", (ListResource)resource, -1);
    } else if (resource instanceof Location) {
      composeLocation(parent, null, "Location", (Location)resource, -1);
    } else if (resource instanceof ManufacturedItemDefinition) {
      composeManufacturedItemDefinition(parent, null, "ManufacturedItemDefinition", (ManufacturedItemDefinition)resource, -1);
    } else if (resource instanceof Measure) {
      composeMeasure(parent, null, "Measure", (Measure)resource, -1);
    } else if (resource instanceof MeasureReport) {
      composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1);
    } else if (resource instanceof Medication) {
      composeMedication(parent, null, "Medication", (Medication)resource, -1);
    } else if (resource instanceof MedicationAdministration) {
      composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1);
    } else if (resource instanceof MedicationDispense) {
      composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1);
    } else if (resource instanceof MedicationKnowledge) {
      composeMedicationKnowledge(parent, null, "MedicationKnowledge", (MedicationKnowledge)resource, -1);
    } else if (resource instanceof MedicationRequest) {
      composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1);
    } else if (resource instanceof MedicationStatement) {
      composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1);
    } else if (resource instanceof MedicinalProductDefinition) {
      composeMedicinalProductDefinition(parent, null, "MedicinalProductDefinition", (MedicinalProductDefinition)resource, -1);
    } else if (resource instanceof MessageDefinition) {
      composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1);
    } else if (resource instanceof MessageHeader) {
      composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1);
    } else if (resource instanceof MolecularSequence) {
      composeMolecularSequence(parent, null, "MolecularSequence", (MolecularSequence)resource, -1);
    } else if (resource instanceof NamingSystem) {
      composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1);
    } else if (resource instanceof NutritionIntake) {
      composeNutritionIntake(parent, null, "NutritionIntake", (NutritionIntake)resource, -1);
    } else if (resource instanceof NutritionOrder) {
      composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1);
    } else if (resource instanceof NutritionProduct) {
      composeNutritionProduct(parent, null, "NutritionProduct", (NutritionProduct)resource, -1);
    } else if (resource instanceof Observation) {
      composeObservation(parent, null, "Observation", (Observation)resource, -1);
    } else if (resource instanceof ObservationDefinition) {
      composeObservationDefinition(parent, null, "ObservationDefinition", (ObservationDefinition)resource, -1);
    } else if (resource instanceof OperationDefinition) {
      composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1);
    } else if (resource instanceof OperationOutcome) {
      composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1);
    } else if (resource instanceof Organization) {
      composeOrganization(parent, null, "Organization", (Organization)resource, -1);
    } else if (resource instanceof OrganizationAffiliation) {
      composeOrganizationAffiliation(parent, null, "OrganizationAffiliation", (OrganizationAffiliation)resource, -1);
    } else if (resource instanceof PackagedProductDefinition) {
      composePackagedProductDefinition(parent, null, "PackagedProductDefinition", (PackagedProductDefinition)resource, -1);
    } else if (resource instanceof Parameters) {
      composeParameters(parent, null, "Parameters", (Parameters)resource, -1);
    } else if (resource instanceof Patient) {
      composePatient(parent, null, "Patient", (Patient)resource, -1);
    } else if (resource instanceof PaymentNotice) {
      composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1);
    } else if (resource instanceof PaymentReconciliation) {
      composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1);
    } else if (resource instanceof Permission) {
      composePermission(parent, null, "Permission", (Permission)resource, -1);
    } else if (resource instanceof Person) {
      composePerson(parent, null, "Person", (Person)resource, -1);
    } else if (resource instanceof PlanDefinition) {
      composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1);
    } else if (resource instanceof Practitioner) {
      composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1);
    } else if (resource instanceof PractitionerRole) {
      composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1);
    } else if (resource instanceof Procedure) {
      composeProcedure(parent, null, "Procedure", (Procedure)resource, -1);
    } else if (resource instanceof Provenance) {
      composeProvenance(parent, null, "Provenance", (Provenance)resource, -1);
    } else if (resource instanceof Questionnaire) {
      composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1);
    } else if (resource instanceof QuestionnaireResponse) {
      composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1);
    } else if (resource instanceof RegulatedAuthorization) {
      composeRegulatedAuthorization(parent, null, "RegulatedAuthorization", (RegulatedAuthorization)resource, -1);
    } else if (resource instanceof RelatedPerson) {
      composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1);
    } else if (resource instanceof RequestOrchestration) {
      composeRequestOrchestration(parent, null, "RequestOrchestration", (RequestOrchestration)resource, -1);
    } else if (resource instanceof Requirements) {
      composeRequirements(parent, null, "Requirements", (Requirements)resource, -1);
    } else if (resource instanceof ResearchStudy) {
      composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1);
    } else if (resource instanceof ResearchSubject) {
      composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1);
    } else if (resource instanceof RiskAssessment) {
      composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1);
    } else if (resource instanceof Schedule) {
      composeSchedule(parent, null, "Schedule", (Schedule)resource, -1);
    } else if (resource instanceof SearchParameter) {
      composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1);
    } else if (resource instanceof ServiceRequest) {
      composeServiceRequest(parent, null, "ServiceRequest", (ServiceRequest)resource, -1);
    } else if (resource instanceof Slot) {
      composeSlot(parent, null, "Slot", (Slot)resource, -1);
    } else if (resource instanceof Specimen) {
      composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1);
    } else if (resource instanceof SpecimenDefinition) {
      composeSpecimenDefinition(parent, null, "SpecimenDefinition", (SpecimenDefinition)resource, -1);
    } else if (resource instanceof StructureDefinition) {
      composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1);
    } else if (resource instanceof StructureMap) {
      composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1);
    } else if (resource instanceof Subscription) {
      composeSubscription(parent, null, "Subscription", (Subscription)resource, -1);
    } else if (resource instanceof SubscriptionStatus) {
      composeSubscriptionStatus(parent, null, "SubscriptionStatus", (SubscriptionStatus)resource, -1);
    } else if (resource instanceof SubscriptionTopic) {
      composeSubscriptionTopic(parent, null, "SubscriptionTopic", (SubscriptionTopic)resource, -1);
    } else if (resource instanceof Substance) {
      composeSubstance(parent, null, "Substance", (Substance)resource, -1);
    } else if (resource instanceof SubstanceDefinition) {
      composeSubstanceDefinition(parent, null, "SubstanceDefinition", (SubstanceDefinition)resource, -1);
    } else if (resource instanceof SubstanceNucleicAcid) {
      composeSubstanceNucleicAcid(parent, null, "SubstanceNucleicAcid", (SubstanceNucleicAcid)resource, -1);
    } else if (resource instanceof SubstancePolymer) {
      composeSubstancePolymer(parent, null, "SubstancePolymer", (SubstancePolymer)resource, -1);
    } else if (resource instanceof SubstanceProtein) {
      composeSubstanceProtein(parent, null, "SubstanceProtein", (SubstanceProtein)resource, -1);
    } else if (resource instanceof SubstanceReferenceInformation) {
      composeSubstanceReferenceInformation(parent, null, "SubstanceReferenceInformation", (SubstanceReferenceInformation)resource, -1);
    } else if (resource instanceof SubstanceSourceMaterial) {
      composeSubstanceSourceMaterial(parent, null, "SubstanceSourceMaterial", (SubstanceSourceMaterial)resource, -1);
    } else if (resource instanceof SupplyDelivery) {
      composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1);
    } else if (resource instanceof SupplyRequest) {
      composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1);
    } else if (resource instanceof Task) {
      composeTask(parent, null, "Task", (Task)resource, -1);
    } else if (resource instanceof TerminologyCapabilities) {
      composeTerminologyCapabilities(parent, null, "TerminologyCapabilities", (TerminologyCapabilities)resource, -1);
    } else if (resource instanceof TestPlan) {
      composeTestPlan(parent, null, "TestPlan", (TestPlan)resource, -1);
    } else if (resource instanceof TestReport) {
      composeTestReport(parent, null, "TestReport", (TestReport)resource, -1);
    } else if (resource instanceof TestScript) {
      composeTestScript(parent, null, "TestScript", (TestScript)resource, -1);
    } else if (resource instanceof Transport) {
      composeTransport(parent, null, "Transport", (Transport)resource, -1);
    } else if (resource instanceof ValueSet) {
      composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1);
    } else if (resource instanceof VerificationResult) {
      composeVerificationResult(parent, null, "VerificationResult", (VerificationResult)resource, -1);
    } else if (resource instanceof VisionPrescription) {
      composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1);
      
    } else {
      throw new Error("Unhandled resource type "+resource.getClass().getName());
    }
  }

  protected void composeType(Complex parent, String parentType, String name, DataType value, int index) {
    if (parent == null) {
      throw new Error("parent == null");
    } else if (parentType == null) {
      throw new Error("parentType == null");
    } else if (name == null) {
      throw new Error("name == null");
    } else if (value == null) {
      throw new Error("value == null");
    } else if (value instanceof DateType) {
      composeDate(parent, parentType, name, (DateType)value, index);
    } else if (value instanceof DateTimeType) {
      composeDateTime(parent, parentType, name, (DateTimeType)value, index);
    } else if (value instanceof CodeType) {
      composeCode(parent, parentType, name, (CodeType)value, index);
    } else if (value instanceof StringType) {
      composeString(parent, parentType, name, (StringType)value, index);
    } else if (value instanceof IntegerType) {
      composeInteger(parent, parentType, name, (IntegerType)value, index);
    } else if (value instanceof Integer64Type) {
      composeInteger64(parent, parentType, name, (Integer64Type)value, index);
    } else if (value instanceof OidType) {
      composeOid(parent, parentType, name, (OidType)value, index);
    } else if (value instanceof CanonicalType) {
      composeCanonical(parent, parentType, name, (CanonicalType)value, index);
    } else if (value instanceof UriType) {
      composeUri(parent, parentType, name, (UriType)value, index);
    } else if (value instanceof UuidType) {
      composeUuid(parent, parentType, name, (UuidType)value, index);
    } else if (value instanceof UrlType) {
      composeUrl(parent, parentType, name, (UrlType)value, index);
    } else if (value instanceof InstantType) {
      composeInstant(parent, parentType, name, (InstantType)value, index);
    } else if (value instanceof BooleanType) {
      composeBoolean(parent, parentType, name, (BooleanType)value, index);
    } else if (value instanceof Base64BinaryType) {
      composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index);
    } else if (value instanceof UnsignedIntType) {
      composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index);
    } else if (value instanceof MarkdownType) {
      composeMarkdown(parent, parentType, name, (MarkdownType)value, index);
    } else if (value instanceof TimeType) {
      composeTime(parent, parentType, name, (TimeType)value, index);
    } else if (value instanceof IdType) {
      composeId(parent, parentType, name, (IdType)value, index);
    } else if (value instanceof PositiveIntType) {
      composePositiveInt(parent, parentType, name, (PositiveIntType)value, index);
    } else if (value instanceof DecimalType) {
      composeDecimal(parent, parentType, name, (DecimalType)value, index);
    } else if (value instanceof Address) {
      composeAddress(parent, parentType, name, (Address)value, index);
    } else if (value instanceof Age) {
      composeAge(parent, parentType, name, (Age)value, index);
    } else if (value instanceof Annotation) {
      composeAnnotation(parent, parentType, name, (Annotation)value, index);
    } else if (value instanceof Attachment) {
      composeAttachment(parent, parentType, name, (Attachment)value, index);
    } else if (value instanceof Availability) {
      composeAvailability(parent, parentType, name, (Availability)value, index);
    } else if (value instanceof CodeableConcept) {
      composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index);
    } else if (value instanceof CodeableReference) {
      composeCodeableReference(parent, parentType, name, (CodeableReference)value, index);
    } else if (value instanceof Coding) {
      composeCoding(parent, parentType, name, (Coding)value, index);
    } else if (value instanceof ContactDetail) {
      composeContactDetail(parent, parentType, name, (ContactDetail)value, index);
    } else if (value instanceof ContactPoint) {
      composeContactPoint(parent, parentType, name, (ContactPoint)value, index);
    } else if (value instanceof Contributor) {
      composeContributor(parent, parentType, name, (Contributor)value, index);
    } else if (value instanceof Count) {
      composeCount(parent, parentType, name, (Count)value, index);
    } else if (value instanceof DataRequirement) {
      composeDataRequirement(parent, parentType, name, (DataRequirement)value, index);
    } else if (value instanceof Distance) {
      composeDistance(parent, parentType, name, (Distance)value, index);
    } else if (value instanceof Dosage) {
      composeDosage(parent, parentType, name, (Dosage)value, index);
    } else if (value instanceof Duration) {
      composeDuration(parent, parentType, name, (Duration)value, index);
    } else if (value instanceof ElementDefinition) {
      composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index);
    } else if (value instanceof Expression) {
      composeExpression(parent, parentType, name, (Expression)value, index);
    } else if (value instanceof ExtendedContactDetail) {
      composeExtendedContactDetail(parent, parentType, name, (ExtendedContactDetail)value, index);
    } else if (value instanceof Extension) {
      composeExtension(parent, parentType, name, (Extension)value, index);
    } else if (value instanceof HumanName) {
      composeHumanName(parent, parentType, name, (HumanName)value, index);
    } else if (value instanceof Identifier) {
      composeIdentifier(parent, parentType, name, (Identifier)value, index);
    } else if (value instanceof MarketingStatus) {
      composeMarketingStatus(parent, parentType, name, (MarketingStatus)value, index);
    } else if (value instanceof Meta) {
      composeMeta(parent, parentType, name, (Meta)value, index);
    } else if (value instanceof MonetaryComponent) {
      composeMonetaryComponent(parent, parentType, name, (MonetaryComponent)value, index);
    } else if (value instanceof Money) {
      composeMoney(parent, parentType, name, (Money)value, index);
    } else if (value instanceof Narrative) {
      composeNarrative(parent, parentType, name, (Narrative)value, index);
    } else if (value instanceof ParameterDefinition) {
      composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index);
    } else if (value instanceof Period) {
      composePeriod(parent, parentType, name, (Period)value, index);
    } else if (value instanceof ProductShelfLife) {
      composeProductShelfLife(parent, parentType, name, (ProductShelfLife)value, index);
    } else if (value instanceof Quantity) {
      composeQuantity(parent, parentType, name, (Quantity)value, index);
    } else if (value instanceof Range) {
      composeRange(parent, parentType, name, (Range)value, index);
    } else if (value instanceof Ratio) {
      composeRatio(parent, parentType, name, (Ratio)value, index);
    } else if (value instanceof RatioRange) {
      composeRatioRange(parent, parentType, name, (RatioRange)value, index);
    } else if (value instanceof Reference) {
      composeReference(parent, parentType, name, (Reference)value, index);
    } else if (value instanceof RelatedArtifact) {
      composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index);
    } else if (value instanceof SampledData) {
      composeSampledData(parent, parentType, name, (SampledData)value, index);
    } else if (value instanceof Signature) {
      composeSignature(parent, parentType, name, (Signature)value, index);
    } else if (value instanceof Timing) {
      composeTiming(parent, parentType, name, (Timing)value, index);
    } else if (value instanceof TriggerDefinition) {
      composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index);
    } else if (value instanceof UsageContext) {
      composeUsageContext(parent, parentType, name, (UsageContext)value, index);
    } else if (value instanceof VirtualServiceDetail) {
      composeVirtualServiceDetail(parent, parentType, name, (VirtualServiceDetail)value, index);
      
    } else {
      throw new Error("Unhandled type");
    }
  }

}