001package org.hl7.fhir.r5.formats;
002
003
004// generated
005
006/*
007  Copyright (c) 2011+, HL7, Inc.
008  All rights reserved.
009  
010  Redistribution and use in source and binary forms, with or without modification, \
011  are permitted provided that the following conditions are met:
012  
013   * Redistributions of source code must retain the above copyright notice, this \
014     list of conditions and the following disclaimer.
015   * Redistributions in binary form must reproduce the above copyright notice, \
016     this list of conditions and the following disclaimer in the documentation \
017     and/or other materials provided with the distribution.
018   * Neither the name of HL7 nor the names of its contributors may be used to 
019     endorse or promote products derived from this software without specific 
020     prior written permission.
021  
022  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
023  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
024  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
025  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
026  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
027  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
028  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
029  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
030  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
031  POSSIBILITY OF SUCH DAMAGE.
032  */
033
034// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
035
036
037
038import org.hl7.fhir.r5.model.*;
039import org.hl7.fhir.r5.model.StringType;
040import org.hl7.fhir.utilities.Utilities;
041import org.hl7.fhir.exceptions.FHIRFormatError;
042import org.hl7.fhir.exceptions.FHIRException;
043import org.hl7.fhir.utilities.turtle.Turtle.*;
044import java.io.IOException;
045
046public class RdfParser extends RdfParserBase {
047
048  public RdfParser() {
049    super();
050  }
051
052  public RdfParser(boolean allowUnknownContent) {
053    super();
054    setAllowUnknownContent(allowUnknownContent);
055  }
056
057  private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) {
058    if (value == null)
059      return;
060    Complex t = parent.predicate("fhir:"+name, index > -1);
061    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
062    composeElement(t, parentType, name, value, index);
063    decorateCode(t, value);
064  }
065
066
067  protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) {
068    if (value == null)
069      return;
070    Complex t = parent.predicate("fhir:"+name, index > -1);
071    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
072    composeElement(t, parentType, name, value, index);
073  }
074
075  protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) {
076    if (value == null)
077      return;
078    Complex t = parent.predicate("fhir:"+name, index > -1);
079    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
080    composeElement(t, parentType, name, value, index);
081  }
082
083  protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) {
084    if (value == null)
085      return;
086    Complex t = parent.predicate("fhir:"+name, index > -1);
087    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
088    composeElement(t, parentType, name, value, index);
089    decorateCode(t, value);
090  }
091
092  protected void composeString(Complex parent, String parentType, String name, StringType value, int index) {
093    if (value == null)
094      return;
095    Complex t = parent.predicate("fhir:"+name, index > -1);
096    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
097    composeElement(t, parentType, name, value, index);
098  }
099
100  protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) {
101    if (value == null)
102      return;
103    Complex t = parent.predicate("fhir:"+name, index > -1);
104    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
105    composeElement(t, parentType, name, value, index);
106  }
107
108  protected void composeInteger64(Complex parent, String parentType, String name, Integer64Type value, int index) {
109    if (value == null)
110      return;
111    Complex t = parent.predicate("fhir:"+name, index > -1);
112    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
113    composeElement(t, parentType, name, value, index);
114  }
115
116  protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) {
117    if (value == null)
118      return;
119    Complex t = parent.predicate("fhir:"+name, index > -1);
120    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
121    composeElement(t, parentType, name, value, index);
122  }
123
124  protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) {
125    if (value == null)
126      return;
127    Complex t = parent.predicate("fhir:"+name, index > -1);
128    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
129    composeElement(t, parentType, name, value, index);
130  }
131
132  protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) {
133    if (value == null)
134      return;
135    Complex t = parent.predicate("fhir:"+name, index > -1);
136    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
137    composeElement(t, parentType, name, value, index);
138  }
139
140  protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) {
141    if (value == null)
142      return;
143    Complex t = parent.predicate("fhir:"+name, index > -1);
144    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
145    composeElement(t, parentType, name, value, index);
146  }
147
148  protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) {
149    if (value == null)
150      return;
151    Complex t = parent.predicate("fhir:"+name, index > -1);
152    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
153    composeElement(t, parentType, name, value, index);
154  }
155
156  protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) {
157    if (value == null)
158      return;
159    Complex t = parent.predicate("fhir:"+name, index > -1);
160    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
161    composeElement(t, parentType, name, value, index);
162  }
163
164  protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) {
165    if (value == null)
166      return;
167    Complex t = parent.predicate("fhir:"+name, index > -1);
168    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
169    composeElement(t, parentType, name, value, index);
170  }
171
172  protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) {
173    if (value == null)
174      return;
175    Complex t = parent.predicate("fhir:"+name, index > -1);
176    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
177    composeElement(t, parentType, name, value, index);
178  }
179
180  protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) {
181    if (value == null)
182      return;
183    Complex t = parent.predicate("fhir:"+name, index > -1);
184    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
185    composeElement(t, parentType, name, value, index);
186  }
187
188  protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) {
189    if (value == null)
190      return;
191    Complex t = parent.predicate("fhir:"+name, index > -1);
192    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
193    composeElement(t, parentType, name, value, index);
194  }
195
196  protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) {
197    if (value == null)
198      return;
199    Complex t = parent.predicate("fhir:"+name, index > -1);
200    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
201    composeElement(t, parentType, name, value, index);
202  }
203
204  protected void composeId(Complex parent, String parentType, String name, IdType value, int index) {
205    if (value == null)
206      return;
207    Complex t = parent.predicate("fhir:"+name, index > -1);
208    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
209    composeElement(t, parentType, name, value, index);
210  }
211
212  protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) {
213    if (value == null)
214      return;
215    Complex t = parent.predicate("fhir:"+name, index > -1);
216    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
217    composeElement(t, parentType, name, value, index);
218  }
219
220  protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) {
221    if (value == null)
222      return;
223    Complex t = parent.predicate("fhir:"+name, index > -1);
224    t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false);
225    composeElement(t, parentType, name, value, index);
226  }
227
228  protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) {
229    composeElement(t, parentType, name, element, index);
230    for (int i = 0; i < element.getModifierExtension().size(); i++) {
231      composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i);
232    }
233  }
234
235  protected void composeBackboneType(Complex t, String parentType, String name, BackboneType element, int index) {
236    composeDataType(t, parentType, name, element, index);
237    for (int i = 0; i < element.getModifierExtension().size(); i++) {
238      composeExtension(t, "BackboneType", "modifierExtension", element.getModifierExtension().get(i), i);
239    }
240  }
241
242  protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) {
243    composeElement(t, parentType, name, element, index);
244  }
245
246  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
247    composeBase(t, parentType, name, element, index);
248    if (element.hasIdElement()) {
249      composeString(t, "Element", "id", element.getIdElement(), -1);
250    }
251    for (int i = 0; i < element.getExtension().size(); i++) {
252      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
253    }
254  }
255
256  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
257    if (element == null) 
258      return;
259    Complex t;
260    if (Utilities.noString(parentType))
261      t = parent;
262    else {
263      t = parent.predicate("fhir:"+name,index > -1);
264    }
265    composeDataType(t, "Address", name, element, index);
266    if (element.hasUseElement()) {
267      composeEnum(t, "Address", "use", element.getUseElement(), -1);
268    }
269    if (element.hasTypeElement()) {
270      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
271    }
272    if (element.hasTextElement()) {
273      composeString(t, "Address", "text", element.getTextElement(), -1);
274    }
275    for (int i = 0; i < element.getLine().size(); i++) {
276      composeString(t, "Address", "line", element.getLine().get(i), i);
277    }
278    if (element.hasCityElement()) {
279      composeString(t, "Address", "city", element.getCityElement(), -1);
280    }
281    if (element.hasDistrictElement()) {
282      composeString(t, "Address", "district", element.getDistrictElement(), -1);
283    }
284    if (element.hasStateElement()) {
285      composeString(t, "Address", "state", element.getStateElement(), -1);
286    }
287    if (element.hasPostalCodeElement()) {
288      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
289    }
290    if (element.hasCountryElement()) {
291      composeString(t, "Address", "country", element.getCountryElement(), -1);
292    }
293    if (element.hasPeriod()) {
294      composePeriod(t, "Address", "period", element.getPeriod(), -1);
295    }
296  }
297
298  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
299    if (element == null) 
300      return;
301    Complex t;
302    if (Utilities.noString(parentType))
303      t = parent;
304    else {
305      t = parent.predicate("fhir:"+name,index > -1);
306    }
307    composeQuantity(t, "Age", name, element, index);
308  }
309
310  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
311    if (element == null) 
312      return;
313    Complex t;
314    if (Utilities.noString(parentType))
315      t = parent;
316    else {
317      t = parent.predicate("fhir:"+name,index > -1);
318    }
319    composeDataType(t, "Annotation", name, element, index);
320    if (element.hasAuthor()) {
321      composeType(t, "Annotation", "author", element.getAuthor(), -1);
322    }
323    if (element.hasTimeElement()) {
324      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
325    }
326    if (element.hasTextElement()) {
327      composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1);
328    }
329  }
330
331  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
332    if (element == null) 
333      return;
334    Complex t;
335    if (Utilities.noString(parentType))
336      t = parent;
337    else {
338      t = parent.predicate("fhir:"+name,index > -1);
339    }
340    composeDataType(t, "Attachment", name, element, index);
341    if (element.hasContentTypeElement()) {
342      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
343    }
344    if (element.hasLanguageElement()) {
345      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
346    }
347    if (element.hasDataElement()) {
348      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
349    }
350    if (element.hasUrlElement()) {
351      composeUrl(t, "Attachment", "url", element.getUrlElement(), -1);
352    }
353    if (element.hasSizeElement()) {
354      composeInteger64(t, "Attachment", "size", element.getSizeElement(), -1);
355    }
356    if (element.hasHashElement()) {
357      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
358    }
359    if (element.hasTitleElement()) {
360      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
361    }
362    if (element.hasCreationElement()) {
363      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
364    }
365    if (element.hasHeightElement()) {
366      composePositiveInt(t, "Attachment", "height", element.getHeightElement(), -1);
367    }
368    if (element.hasWidthElement()) {
369      composePositiveInt(t, "Attachment", "width", element.getWidthElement(), -1);
370    }
371    if (element.hasFramesElement()) {
372      composePositiveInt(t, "Attachment", "frames", element.getFramesElement(), -1);
373    }
374    if (element.hasDurationElement()) {
375      composeDecimal(t, "Attachment", "duration", element.getDurationElement(), -1);
376    }
377    if (element.hasPagesElement()) {
378      composePositiveInt(t, "Attachment", "pages", element.getPagesElement(), -1);
379    }
380  }
381
382  protected void composeAvailability(Complex parent, String parentType, String name, Availability element, int index) {
383    if (element == null) 
384      return;
385    Complex t;
386    if (Utilities.noString(parentType))
387      t = parent;
388    else {
389      t = parent.predicate("fhir:"+name,index > -1);
390    }
391    composeDataType(t, "Availability", name, element, index);
392    for (int i = 0; i < element.getAvailableTime().size(); i++) {
393      composeAvailabilityAvailableTimeComponent(t, "Availability", "availableTime", element.getAvailableTime().get(i), i);
394    }
395    for (int i = 0; i < element.getNotAvailableTime().size(); i++) {
396      composeAvailabilityNotAvailableTimeComponent(t, "Availability", "notAvailableTime", element.getNotAvailableTime().get(i), i);
397    }
398  }
399
400  protected void composeAvailabilityAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityAvailableTimeComponent element, int index) {
401    if (element == null) 
402      return;
403    Complex t;
404    if (Utilities.noString(parentType))
405      t = parent;
406    else {
407      t = parent.predicate("fhir:"+name,index > -1);
408    }
409    composeElement(t, "availableTime", name, element, index);
410    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
411      composeEnum(t, "AvailabilityAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
412    }
413    if (element.hasAllDayElement()) {
414      composeBoolean(t, "AvailabilityAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
415    }
416    if (element.hasAvailableStartTimeElement()) {
417      composeTime(t, "AvailabilityAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
418    }
419    if (element.hasAvailableEndTimeElement()) {
420      composeTime(t, "AvailabilityAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
421    }
422  }
423
424  protected void composeAvailabilityNotAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityNotAvailableTimeComponent element, int index) {
425    if (element == null) 
426      return;
427    Complex t;
428    if (Utilities.noString(parentType))
429      t = parent;
430    else {
431      t = parent.predicate("fhir:"+name,index > -1);
432    }
433    composeElement(t, "notAvailableTime", name, element, index);
434    if (element.hasDescriptionElement()) {
435      composeString(t, "AvailabilityNotAvailableTimeComponent", "description", element.getDescriptionElement(), -1);
436    }
437    if (element.hasDuring()) {
438      composePeriod(t, "AvailabilityNotAvailableTimeComponent", "during", element.getDuring(), -1);
439    }
440  }
441
442  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
443    if (element == null) 
444      return;
445    Complex t;
446    if (Utilities.noString(parentType))
447      t = parent;
448    else {
449      t = parent.predicate("fhir:"+name,index > -1);
450    }
451    composeDataType(t, "CodeableConcept", name, element, index);
452    decorateCodeableConcept(t, element);
453    for (int i = 0; i < element.getCoding().size(); i++) {
454      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
455    }
456    if (element.hasTextElement()) {
457      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
458    }
459  }
460
461  protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) {
462    if (element == null) 
463      return;
464    Complex t;
465    if (Utilities.noString(parentType))
466      t = parent;
467    else {
468      t = parent.predicate("fhir:"+name,index > -1);
469    }
470    composeDataType(t, "CodeableReference", name, element, index);
471    if (element.hasConcept()) {
472      composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1);
473    }
474    if (element.hasReference()) {
475      composeReference(t, "CodeableReference", "reference", element.getReference(), -1);
476    }
477  }
478
479  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
480    if (element == null) 
481      return;
482    Complex t;
483    if (Utilities.noString(parentType))
484      t = parent;
485    else {
486      t = parent.predicate("fhir:"+name,index > -1);
487    }
488    composeDataType(t, "Coding", name, element, index);
489    decorateCoding(t, element);
490    if (element.hasSystemElement()) {
491      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
492    }
493    if (element.hasVersionElement()) {
494      composeString(t, "Coding", "version", element.getVersionElement(), -1);
495    }
496    if (element.hasCodeElement()) {
497      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
498    }
499    if (element.hasDisplayElement()) {
500      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
501    }
502    if (element.hasUserSelectedElement()) {
503      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
504    }
505  }
506
507  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) {
508    if (element == null) 
509      return;
510    Complex t;
511    if (Utilities.noString(parentType))
512      t = parent;
513    else {
514      t = parent.predicate("fhir:"+name,index > -1);
515    }
516    composeDataType(t, "ContactDetail", name, element, index);
517    if (element.hasNameElement()) {
518      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
519    }
520    for (int i = 0; i < element.getTelecom().size(); i++) {
521      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
522    }
523  }
524
525  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) {
526    if (element == null) 
527      return;
528    Complex t;
529    if (Utilities.noString(parentType))
530      t = parent;
531    else {
532      t = parent.predicate("fhir:"+name,index > -1);
533    }
534    composeDataType(t, "ContactPoint", name, element, index);
535    if (element.hasSystemElement()) {
536      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
537    }
538    if (element.hasValueElement()) {
539      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
540    }
541    if (element.hasUseElement()) {
542      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
543    }
544    if (element.hasRankElement()) {
545      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
546    }
547    if (element.hasPeriod()) {
548      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
549    }
550  }
551
552  protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) {
553    if (element == null) 
554      return;
555    Complex t;
556    if (Utilities.noString(parentType))
557      t = parent;
558    else {
559      t = parent.predicate("fhir:"+name,index > -1);
560    }
561    composeDataType(t, "Contributor", name, element, index);
562    if (element.hasTypeElement()) {
563      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
564    }
565    if (element.hasNameElement()) {
566      composeString(t, "Contributor", "name", element.getNameElement(), -1);
567    }
568    for (int i = 0; i < element.getContact().size(); i++) {
569      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
570    }
571  }
572
573  protected void composeCount(Complex parent, String parentType, String name, Count element, int index) {
574    if (element == null) 
575      return;
576    Complex t;
577    if (Utilities.noString(parentType))
578      t = parent;
579    else {
580      t = parent.predicate("fhir:"+name,index > -1);
581    }
582    composeQuantity(t, "Count", name, element, index);
583  }
584
585  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) {
586    if (element == null) 
587      return;
588    Complex t;
589    if (Utilities.noString(parentType))
590      t = parent;
591    else {
592      t = parent.predicate("fhir:"+name,index > -1);
593    }
594    composeDataType(t, "DataRequirement", name, element, index);
595    if (element.hasTypeElement()) {
596      composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1);
597    }
598    for (int i = 0; i < element.getProfile().size(); i++) {
599      composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i);
600    }
601    if (element.hasSubject()) {
602      composeType(t, "DataRequirement", "subject", element.getSubject(), -1);
603    }
604    for (int i = 0; i < element.getMustSupport().size(); i++) {
605      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
606    }
607    for (int i = 0; i < element.getCodeFilter().size(); i++) {
608      composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
609    }
610    for (int i = 0; i < element.getDateFilter().size(); i++) {
611      composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
612    }
613    for (int i = 0; i < element.getValueFilter().size(); i++) {
614      composeDataRequirementValueFilterComponent(t, "DataRequirement", "valueFilter", element.getValueFilter().get(i), i);
615    }
616    if (element.hasLimitElement()) {
617      composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1);
618    }
619    for (int i = 0; i < element.getSort().size(); i++) {
620      composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i);
621    }
622  }
623
624  protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
625    if (element == null) 
626      return;
627    Complex t;
628    if (Utilities.noString(parentType))
629      t = parent;
630    else {
631      t = parent.predicate("fhir:"+name,index > -1);
632    }
633    composeElement(t, "codeFilter", name, element, index);
634    if (element.hasPathElement()) {
635      composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1);
636    }
637    if (element.hasSearchParamElement()) {
638      composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1);
639    }
640    if (element.hasValueSetElement()) {
641      composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1);
642    }
643    for (int i = 0; i < element.getCode().size(); i++) {
644      composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i);
645    }
646  }
647
648  protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
649    if (element == null) 
650      return;
651    Complex t;
652    if (Utilities.noString(parentType))
653      t = parent;
654    else {
655      t = parent.predicate("fhir:"+name,index > -1);
656    }
657    composeElement(t, "dateFilter", name, element, index);
658    if (element.hasPathElement()) {
659      composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1);
660    }
661    if (element.hasSearchParamElement()) {
662      composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1);
663    }
664    if (element.hasValue()) {
665      composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1);
666    }
667  }
668
669  protected void composeDataRequirementValueFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementValueFilterComponent element, int index) {
670    if (element == null) 
671      return;
672    Complex t;
673    if (Utilities.noString(parentType))
674      t = parent;
675    else {
676      t = parent.predicate("fhir:"+name,index > -1);
677    }
678    composeElement(t, "valueFilter", name, element, index);
679    if (element.hasPathElement()) {
680      composeString(t, "DataRequirementValueFilterComponent", "path", element.getPathElement(), -1);
681    }
682    if (element.hasSearchParamElement()) {
683      composeString(t, "DataRequirementValueFilterComponent", "searchParam", element.getSearchParamElement(), -1);
684    }
685    if (element.hasComparatorElement()) {
686      composeEnum(t, "DataRequirementValueFilterComponent", "comparator", element.getComparatorElement(), -1);
687    }
688    if (element.hasValue()) {
689      composeType(t, "DataRequirementValueFilterComponent", "value", element.getValue(), -1);
690    }
691  }
692
693  protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) {
694    if (element == null) 
695      return;
696    Complex t;
697    if (Utilities.noString(parentType))
698      t = parent;
699    else {
700      t = parent.predicate("fhir:"+name,index > -1);
701    }
702    composeElement(t, "sort", name, element, index);
703    if (element.hasPathElement()) {
704      composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1);
705    }
706    if (element.hasDirectionElement()) {
707      composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1);
708    }
709  }
710
711  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
712    if (element == null) 
713      return;
714    Complex t;
715    if (Utilities.noString(parentType))
716      t = parent;
717    else {
718      t = parent.predicate("fhir:"+name,index > -1);
719    }
720    composeQuantity(t, "Distance", name, element, index);
721  }
722
723  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
724    if (element == null) 
725      return;
726    Complex t;
727    if (Utilities.noString(parentType))
728      t = parent;
729    else {
730      t = parent.predicate("fhir:"+name,index > -1);
731    }
732    composeBackboneType(t, "Dosage", name, element, index);
733    if (element.hasSequenceElement()) {
734      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
735    }
736    if (element.hasTextElement()) {
737      composeString(t, "Dosage", "text", element.getTextElement(), -1);
738    }
739    for (int i = 0; i < element.getAdditionalInstruction().size(); i++) {
740      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
741    }
742    if (element.hasPatientInstructionElement()) {
743      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
744    }
745    if (element.hasTiming()) {
746      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
747    }
748    if (element.hasAsNeededElement()) {
749      composeBoolean(t, "Dosage", "asNeeded", element.getAsNeededElement(), -1);
750    }
751    for (int i = 0; i < element.getAsNeededFor().size(); i++) {
752      composeCodeableConcept(t, "Dosage", "asNeededFor", element.getAsNeededFor().get(i), i);
753    }
754    if (element.hasSite()) {
755      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
756    }
757    if (element.hasRoute()) {
758      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
759    }
760    if (element.hasMethod()) {
761      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
762    }
763    for (int i = 0; i < element.getDoseAndRate().size(); i++) {
764      composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i);
765    }
766    for (int i = 0; i < element.getMaxDosePerPeriod().size(); i++) {
767      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod().get(i), i);
768    }
769    if (element.hasMaxDosePerAdministration()) {
770      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
771    }
772    if (element.hasMaxDosePerLifetime()) {
773      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
774    }
775  }
776
777  protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) {
778    if (element == null) 
779      return;
780    Complex t;
781    if (Utilities.noString(parentType))
782      t = parent;
783    else {
784      t = parent.predicate("fhir:"+name,index > -1);
785    }
786    composeElement(t, "doseAndRate", name, element, index);
787    if (element.hasType()) {
788      composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1);
789    }
790    if (element.hasDose()) {
791      composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1);
792    }
793    if (element.hasRate()) {
794      composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1);
795    }
796  }
797
798  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
799    if (element == null) 
800      return;
801    Complex t;
802    if (Utilities.noString(parentType))
803      t = parent;
804    else {
805      t = parent.predicate("fhir:"+name,index > -1);
806    }
807    composeQuantity(t, "Duration", name, element, index);
808  }
809
810  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
811    if (element == null) 
812      return;
813    Complex t;
814    if (Utilities.noString(parentType))
815      t = parent;
816    else {
817      t = parent.predicate("fhir:"+name,index > -1);
818    }
819    composeBackboneType(t, "ElementDefinition", name, element, index);
820    if (element.hasPathElement()) {
821      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
822    }
823    for (int i = 0; i < element.getRepresentation().size(); i++) {
824      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
825    }
826    if (element.hasSliceNameElement()) {
827      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
828    }
829    if (element.hasSliceIsConstrainingElement()) {
830      composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1);
831    }
832    if (element.hasLabelElement()) {
833      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
834    }
835    for (int i = 0; i < element.getCode().size(); i++) {
836      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
837    }
838    if (element.hasSlicing()) {
839      composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
840    }
841    if (element.hasShortElement()) {
842      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
843    }
844    if (element.hasDefinitionElement()) {
845      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
846    }
847    if (element.hasCommentElement()) {
848      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
849    }
850    if (element.hasRequirementsElement()) {
851      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
852    }
853    for (int i = 0; i < element.getAlias().size(); i++) {
854      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
855    }
856    if (element.hasMinElement()) {
857      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
858    }
859    if (element.hasMaxElement()) {
860      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
861    }
862    if (element.hasBase()) {
863      composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
864    }
865    if (element.hasContentReferenceElement()) {
866      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
867    }
868    for (int i = 0; i < element.getType().size(); i++) {
869      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
870    }
871    if (element.hasDefaultValue()) {
872      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
873    }
874    if (element.hasMeaningWhenMissingElement()) {
875      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
876    }
877    if (element.hasOrderMeaningElement()) {
878      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
879    }
880    if (element.hasFixed()) {
881      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
882    }
883    if (element.hasPattern()) {
884      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
885    }
886    for (int i = 0; i < element.getExample().size(); i++) {
887      composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
888    }
889    if (element.hasMinValue()) {
890      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
891    }
892    if (element.hasMaxValue()) {
893      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
894    }
895    if (element.hasMaxLengthElement()) {
896      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
897    }
898    for (int i = 0; i < element.getCondition().size(); i++) {
899      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
900    }
901    for (int i = 0; i < element.getConstraint().size(); i++) {
902      composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
903    }
904    if (element.hasMustHaveValueElement()) {
905      composeBoolean(t, "ElementDefinition", "mustHaveValue", element.getMustHaveValueElement(), -1);
906    }
907    for (int i = 0; i < element.getValueAlternatives().size(); i++) {
908      composeCanonical(t, "ElementDefinition", "valueAlternatives", element.getValueAlternatives().get(i), i);
909    }
910    if (element.hasMustSupportElement()) {
911      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
912    }
913    if (element.hasIsModifierElement()) {
914      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
915    }
916    if (element.hasIsModifierReasonElement()) {
917      composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1);
918    }
919    if (element.hasIsSummaryElement()) {
920      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
921    }
922    if (element.hasBinding()) {
923      composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
924    }
925    for (int i = 0; i < element.getMapping().size(); i++) {
926      composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
927    }
928  }
929
930  protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) {
931    if (element == null) 
932      return;
933    Complex t;
934    if (Utilities.noString(parentType))
935      t = parent;
936    else {
937      t = parent.predicate("fhir:"+name,index > -1);
938    }
939    composeElement(t, "slicing", name, element, index);
940    for (int i = 0; i < element.getDiscriminator().size(); i++) {
941      composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i);
942    }
943    if (element.hasDescriptionElement()) {
944      composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1);
945    }
946    if (element.hasOrderedElement()) {
947      composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1);
948    }
949    if (element.hasRulesElement()) {
950      composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1);
951    }
952  }
953
954  protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
955    if (element == null) 
956      return;
957    Complex t;
958    if (Utilities.noString(parentType))
959      t = parent;
960    else {
961      t = parent.predicate("fhir:"+name,index > -1);
962    }
963    composeElement(t, "discriminator", name, element, index);
964    if (element.hasTypeElement()) {
965      composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1);
966    }
967    if (element.hasPathElement()) {
968      composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1);
969    }
970  }
971
972  protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
973    if (element == null) 
974      return;
975    Complex t;
976    if (Utilities.noString(parentType))
977      t = parent;
978    else {
979      t = parent.predicate("fhir:"+name,index > -1);
980    }
981    composeElement(t, "base", name, element, index);
982    if (element.hasPathElement()) {
983      composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1);
984    }
985    if (element.hasMinElement()) {
986      composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1);
987    }
988    if (element.hasMaxElement()) {
989      composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1);
990    }
991  }
992
993  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
994    if (element == null) 
995      return;
996    Complex t;
997    if (Utilities.noString(parentType))
998      t = parent;
999    else {
1000      t = parent.predicate("fhir:"+name,index > -1);
1001    }
1002    composeElement(t, "type", name, element, index);
1003    if (element.hasCodeElement()) {
1004      composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1);
1005    }
1006    for (int i = 0; i < element.getProfile().size(); i++) {
1007      composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i);
1008    }
1009    for (int i = 0; i < element.getTargetProfile().size(); i++) {
1010      composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i);
1011    }
1012    for (int i = 0; i < element.getAggregation().size(); i++) {
1013      composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i);
1014    }
1015    if (element.hasVersioningElement()) {
1016      composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1);
1017    }
1018  }
1019
1020  protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
1021    if (element == null) 
1022      return;
1023    Complex t;
1024    if (Utilities.noString(parentType))
1025      t = parent;
1026    else {
1027      t = parent.predicate("fhir:"+name,index > -1);
1028    }
1029    composeElement(t, "example", name, element, index);
1030    if (element.hasLabelElement()) {
1031      composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1);
1032    }
1033    if (element.hasValue()) {
1034      composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1);
1035    }
1036  }
1037
1038  protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
1039    if (element == null) 
1040      return;
1041    Complex t;
1042    if (Utilities.noString(parentType))
1043      t = parent;
1044    else {
1045      t = parent.predicate("fhir:"+name,index > -1);
1046    }
1047    composeElement(t, "constraint", name, element, index);
1048    if (element.hasKeyElement()) {
1049      composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1);
1050    }
1051    if (element.hasRequirementsElement()) {
1052      composeMarkdown(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1);
1053    }
1054    if (element.hasSeverityElement()) {
1055      composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1);
1056    }
1057    if (element.hasSuppressElement()) {
1058      composeBoolean(t, "ElementDefinitionConstraintComponent", "suppress", element.getSuppressElement(), -1);
1059    }
1060    if (element.hasHumanElement()) {
1061      composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1);
1062    }
1063    if (element.hasExpressionElement()) {
1064      composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1);
1065    }
1066    if (element.hasSourceElement()) {
1067      composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1);
1068    }
1069  }
1070
1071  protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
1072    if (element == null) 
1073      return;
1074    Complex t;
1075    if (Utilities.noString(parentType))
1076      t = parent;
1077    else {
1078      t = parent.predicate("fhir:"+name,index > -1);
1079    }
1080    composeElement(t, "binding", name, element, index);
1081    if (element.hasStrengthElement()) {
1082      composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1);
1083    }
1084    if (element.hasDescriptionElement()) {
1085      composeMarkdown(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1);
1086    }
1087    if (element.hasValueSetElement()) {
1088      composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1);
1089    }
1090    for (int i = 0; i < element.getAdditional().size(); i++) {
1091      composeElementDefinitionBindingAdditionalComponent(t, "ElementDefinitionBindingComponent", "additional", element.getAdditional().get(i), i);
1092    }
1093  }
1094
1095  protected void composeElementDefinitionBindingAdditionalComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingAdditionalComponent element, int index) {
1096    if (element == null) 
1097      return;
1098    Complex t;
1099    if (Utilities.noString(parentType))
1100      t = parent;
1101    else {
1102      t = parent.predicate("fhir:"+name,index > -1);
1103    }
1104    composeElement(t, "additional", name, element, index);
1105    if (element.hasPurposeElement()) {
1106      composeEnum(t, "ElementDefinitionBindingAdditionalComponent", "purpose", element.getPurposeElement(), -1);
1107    }
1108    if (element.hasValueSetElement()) {
1109      composeCanonical(t, "ElementDefinitionBindingAdditionalComponent", "valueSet", element.getValueSetElement(), -1);
1110    }
1111    if (element.hasDocumentationElement()) {
1112      composeMarkdown(t, "ElementDefinitionBindingAdditionalComponent", "documentation", element.getDocumentationElement(), -1);
1113    }
1114    if (element.hasShortDocoElement()) {
1115      composeString(t, "ElementDefinitionBindingAdditionalComponent", "shortDoco", element.getShortDocoElement(), -1);
1116    }
1117    for (int i = 0; i < element.getUsage().size(); i++) {
1118      composeUsageContext(t, "ElementDefinitionBindingAdditionalComponent", "usage", element.getUsage().get(i), i);
1119    }
1120    if (element.hasAnyElement()) {
1121      composeBoolean(t, "ElementDefinitionBindingAdditionalComponent", "any", element.getAnyElement(), -1);
1122    }
1123  }
1124
1125  protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
1126    if (element == null) 
1127      return;
1128    Complex t;
1129    if (Utilities.noString(parentType))
1130      t = parent;
1131    else {
1132      t = parent.predicate("fhir:"+name,index > -1);
1133    }
1134    composeElement(t, "mapping", name, element, index);
1135    if (element.hasIdentityElement()) {
1136      composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
1137    }
1138    if (element.hasLanguageElement()) {
1139      composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1);
1140    }
1141    if (element.hasMapElement()) {
1142      composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1);
1143    }
1144    if (element.hasCommentElement()) {
1145      composeMarkdown(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
1146    }
1147  }
1148
1149  protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) {
1150    if (element == null) 
1151      return;
1152    Complex t;
1153    if (Utilities.noString(parentType))
1154      t = parent;
1155    else {
1156      t = parent.predicate("fhir:"+name,index > -1);
1157    }
1158    composeDataType(t, "Expression", name, element, index);
1159    if (element.hasDescriptionElement()) {
1160      composeString(t, "Expression", "description", element.getDescriptionElement(), -1);
1161    }
1162    if (element.hasNameElement()) {
1163      composeCode(t, "Expression", "name", element.getNameElement(), -1);
1164    }
1165    if (element.hasLanguageElement()) {
1166      composeCode(t, "Expression", "language", element.getLanguageElement(), -1);
1167    }
1168    if (element.hasExpressionElement()) {
1169      composeString(t, "Expression", "expression", element.getExpressionElement(), -1);
1170    }
1171    if (element.hasReferenceElement()) {
1172      composeUri(t, "Expression", "reference", element.getReferenceElement(), -1);
1173    }
1174  }
1175
1176  protected void composeExtendedContactDetail(Complex parent, String parentType, String name, ExtendedContactDetail element, int index) {
1177    if (element == null) 
1178      return;
1179    Complex t;
1180    if (Utilities.noString(parentType))
1181      t = parent;
1182    else {
1183      t = parent.predicate("fhir:"+name,index > -1);
1184    }
1185    composeDataType(t, "ExtendedContactDetail", name, element, index);
1186    if (element.hasPurpose()) {
1187      composeCodeableConcept(t, "ExtendedContactDetail", "purpose", element.getPurpose(), -1);
1188    }
1189    for (int i = 0; i < element.getName().size(); i++) {
1190      composeHumanName(t, "ExtendedContactDetail", "name", element.getName().get(i), i);
1191    }
1192    for (int i = 0; i < element.getTelecom().size(); i++) {
1193      composeContactPoint(t, "ExtendedContactDetail", "telecom", element.getTelecom().get(i), i);
1194    }
1195    if (element.hasAddress()) {
1196      composeAddress(t, "ExtendedContactDetail", "address", element.getAddress(), -1);
1197    }
1198    if (element.hasOrganization()) {
1199      composeReference(t, "ExtendedContactDetail", "organization", element.getOrganization(), -1);
1200    }
1201    if (element.hasPeriod()) {
1202      composePeriod(t, "ExtendedContactDetail", "period", element.getPeriod(), -1);
1203    }
1204  }
1205
1206  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
1207    if (element == null) 
1208      return;
1209    Complex t;
1210    if (Utilities.noString(parentType))
1211      t = parent;
1212    else {
1213      t = parent.predicate("fhir:"+name,index > -1);
1214    }
1215    composeDataType(t, "Extension", name, element, index);
1216    if (element.hasUrlElement()) {
1217      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
1218    }
1219    if (element.hasValue()) {
1220      composeType(t, "Extension", "value", element.getValue(), -1);
1221    }
1222  }
1223
1224  protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) {
1225    if (element == null) 
1226      return;
1227    Complex t;
1228    if (Utilities.noString(parentType))
1229      t = parent;
1230    else {
1231      t = parent.predicate("fhir:"+name,index > -1);
1232    }
1233    composeDataType(t, "HumanName", name, element, index);
1234    if (element.hasUseElement()) {
1235      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
1236    }
1237    if (element.hasTextElement()) {
1238      composeString(t, "HumanName", "text", element.getTextElement(), -1);
1239    }
1240    if (element.hasFamilyElement()) {
1241      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
1242    }
1243    for (int i = 0; i < element.getGiven().size(); i++) {
1244      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
1245    }
1246    for (int i = 0; i < element.getPrefix().size(); i++) {
1247      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
1248    }
1249    for (int i = 0; i < element.getSuffix().size(); i++) {
1250      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
1251    }
1252    if (element.hasPeriod()) {
1253      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
1254    }
1255  }
1256
1257  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
1258    if (element == null) 
1259      return;
1260    Complex t;
1261    if (Utilities.noString(parentType))
1262      t = parent;
1263    else {
1264      t = parent.predicate("fhir:"+name,index > -1);
1265    }
1266    composeDataType(t, "Identifier", name, element, index);
1267    if (element.hasUseElement()) {
1268      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
1269    }
1270    if (element.hasType()) {
1271      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
1272    }
1273    if (element.hasSystemElement()) {
1274      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
1275    }
1276    if (element.hasValueElement()) {
1277      composeString(t, "Identifier", "value", element.getValueElement(), -1);
1278    }
1279    if (element.hasPeriod()) {
1280      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
1281    }
1282    if (element.hasAssigner()) {
1283      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
1284    }
1285  }
1286
1287  protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) {
1288    if (element == null) 
1289      return;
1290    Complex t;
1291    if (Utilities.noString(parentType))
1292      t = parent;
1293    else {
1294      t = parent.predicate("fhir:"+name,index > -1);
1295    }
1296    composeBackboneType(t, "MarketingStatus", name, element, index);
1297    if (element.hasCountry()) {
1298      composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1);
1299    }
1300    if (element.hasJurisdiction()) {
1301      composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1);
1302    }
1303    if (element.hasStatus()) {
1304      composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1);
1305    }
1306    if (element.hasDateRange()) {
1307      composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1);
1308    }
1309    if (element.hasRestoreDateElement()) {
1310      composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1);
1311    }
1312  }
1313
1314  protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) {
1315    if (element == null) 
1316      return;
1317    Complex t;
1318    if (Utilities.noString(parentType))
1319      t = parent;
1320    else {
1321      t = parent.predicate("fhir:"+name,index > -1);
1322    }
1323    composeDataType(t, "Meta", name, element, index);
1324    if (element.hasVersionIdElement()) {
1325      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
1326    }
1327    if (element.hasLastUpdatedElement()) {
1328      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
1329    }
1330    if (element.hasSourceElement()) {
1331      composeUri(t, "Meta", "source", element.getSourceElement(), -1);
1332    }
1333    for (int i = 0; i < element.getProfile().size(); i++) {
1334      composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i);
1335    }
1336    for (int i = 0; i < element.getSecurity().size(); i++) {
1337      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
1338    }
1339    for (int i = 0; i < element.getTag().size(); i++) {
1340      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
1341    }
1342  }
1343
1344  protected void composeMonetaryComponent(Complex parent, String parentType, String name, MonetaryComponent element, int index) {
1345    if (element == null) 
1346      return;
1347    Complex t;
1348    if (Utilities.noString(parentType))
1349      t = parent;
1350    else {
1351      t = parent.predicate("fhir:"+name,index > -1);
1352    }
1353    composeDataType(t, "MonetaryComponent", name, element, index);
1354    if (element.hasTypeElement()) {
1355      composeEnum(t, "MonetaryComponent", "type", element.getTypeElement(), -1);
1356    }
1357    if (element.hasCode()) {
1358      composeCodeableConcept(t, "MonetaryComponent", "code", element.getCode(), -1);
1359    }
1360    if (element.hasFactorElement()) {
1361      composeDecimal(t, "MonetaryComponent", "factor", element.getFactorElement(), -1);
1362    }
1363    if (element.hasAmount()) {
1364      composeMoney(t, "MonetaryComponent", "amount", element.getAmount(), -1);
1365    }
1366  }
1367
1368  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
1369    if (element == null) 
1370      return;
1371    Complex t;
1372    if (Utilities.noString(parentType))
1373      t = parent;
1374    else {
1375      t = parent.predicate("fhir:"+name,index > -1);
1376    }
1377    composeDataType(t, "Money", name, element, index);
1378    if (element.hasValueElement()) {
1379      composeDecimal(t, "Money", "value", element.getValueElement(), -1);
1380    }
1381    if (element.hasCurrencyElement()) {
1382      composeCode(t, "Money", "currency", element.getCurrencyElement(), -1);
1383    }
1384  }
1385
1386  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
1387    if (element == null) 
1388      return;
1389    Complex t;
1390    if (Utilities.noString(parentType))
1391      t = parent;
1392    else {
1393      t = parent.predicate("fhir:"+name,index > -1);
1394    }
1395    composeDataType(t, "Narrative", name, element, index);
1396    if (element.hasStatusElement()) {
1397      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
1398    }
1399    if (element.hasDiv()) {
1400      composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1);
1401    }
1402  }
1403
1404  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
1405    if (element == null) 
1406      return;
1407    Complex t;
1408    if (Utilities.noString(parentType))
1409      t = parent;
1410    else {
1411      t = parent.predicate("fhir:"+name,index > -1);
1412    }
1413    composeDataType(t, "ParameterDefinition", name, element, index);
1414    if (element.hasNameElement()) {
1415      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
1416    }
1417    if (element.hasUseElement()) {
1418      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
1419    }
1420    if (element.hasMinElement()) {
1421      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
1422    }
1423    if (element.hasMaxElement()) {
1424      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
1425    }
1426    if (element.hasDocumentationElement()) {
1427      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
1428    }
1429    if (element.hasTypeElement()) {
1430      composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
1431    }
1432    if (element.hasProfileElement()) {
1433      composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1);
1434    }
1435  }
1436
1437  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
1438    if (element == null) 
1439      return;
1440    Complex t;
1441    if (Utilities.noString(parentType))
1442      t = parent;
1443    else {
1444      t = parent.predicate("fhir:"+name,index > -1);
1445    }
1446    composeDataType(t, "Period", name, element, index);
1447    if (element.hasStartElement()) {
1448      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
1449    }
1450    if (element.hasEndElement()) {
1451      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
1452    }
1453  }
1454
1455  protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) {
1456    if (element == null) 
1457      return;
1458    Complex t;
1459    if (Utilities.noString(parentType))
1460      t = parent;
1461    else {
1462      t = parent.predicate("fhir:"+name,index > -1);
1463    }
1464    composeBackboneType(t, "ProductShelfLife", name, element, index);
1465    if (element.hasType()) {
1466      composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1);
1467    }
1468    if (element.hasPeriod()) {
1469      composeType(t, "ProductShelfLife", "period", element.getPeriod(), -1);
1470    }
1471    for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) {
1472      composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i);
1473    }
1474  }
1475
1476  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
1477    if (element == null) 
1478      return;
1479    Complex t;
1480    if (Utilities.noString(parentType))
1481      t = parent;
1482    else {
1483      t = parent.predicate("fhir:"+name,index > -1);
1484    }
1485    composeDataType(t, "Quantity", name, element, index);
1486    if (element.hasValueElement()) {
1487      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
1488    }
1489    if (element.hasComparatorElement()) {
1490      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
1491    }
1492    if (element.hasUnitElement()) {
1493      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
1494    }
1495    if (element.hasSystemElement()) {
1496      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
1497    }
1498    if (element.hasCodeElement()) {
1499      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
1500    }
1501  }
1502
1503  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
1504    if (element == null) 
1505      return;
1506    Complex t;
1507    if (Utilities.noString(parentType))
1508      t = parent;
1509    else {
1510      t = parent.predicate("fhir:"+name,index > -1);
1511    }
1512    composeDataType(t, "Range", name, element, index);
1513    if (element.hasLow()) {
1514      composeQuantity(t, "Range", "low", element.getLow(), -1);
1515    }
1516    if (element.hasHigh()) {
1517      composeQuantity(t, "Range", "high", element.getHigh(), -1);
1518    }
1519  }
1520
1521  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
1522    if (element == null) 
1523      return;
1524    Complex t;
1525    if (Utilities.noString(parentType))
1526      t = parent;
1527    else {
1528      t = parent.predicate("fhir:"+name,index > -1);
1529    }
1530    composeDataType(t, "Ratio", name, element, index);
1531    if (element.hasNumerator()) {
1532      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
1533    }
1534    if (element.hasDenominator()) {
1535      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
1536    }
1537  }
1538
1539  protected void composeRatioRange(Complex parent, String parentType, String name, RatioRange element, int index) {
1540    if (element == null) 
1541      return;
1542    Complex t;
1543    if (Utilities.noString(parentType))
1544      t = parent;
1545    else {
1546      t = parent.predicate("fhir:"+name,index > -1);
1547    }
1548    composeDataType(t, "RatioRange", name, element, index);
1549    if (element.hasLowNumerator()) {
1550      composeQuantity(t, "RatioRange", "lowNumerator", element.getLowNumerator(), -1);
1551    }
1552    if (element.hasHighNumerator()) {
1553      composeQuantity(t, "RatioRange", "highNumerator", element.getHighNumerator(), -1);
1554    }
1555    if (element.hasDenominator()) {
1556      composeQuantity(t, "RatioRange", "denominator", element.getDenominator(), -1);
1557    }
1558  }
1559
1560  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
1561    if (element == null) 
1562      return;
1563    Complex t;
1564    if (Utilities.noString(parentType))
1565      t = parent;
1566    else {
1567      t = parent.predicate("fhir:"+name,index > -1);
1568    }
1569    composeDataType(t, "Reference", name, element, index);
1570    if (element.hasReferenceElement()) {
1571      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
1572    }
1573    if (element.hasTypeElement()) {
1574      composeUri(t, "Reference", "type", element.getTypeElement(), -1);
1575    }
1576    if (element.hasIdentifier()) {
1577      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
1578    }
1579    if (element.hasDisplayElement()) {
1580      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
1581    }
1582  }
1583
1584  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
1585    if (element == null) 
1586      return;
1587    Complex t;
1588    if (Utilities.noString(parentType))
1589      t = parent;
1590    else {
1591      t = parent.predicate("fhir:"+name,index > -1);
1592    }
1593    composeDataType(t, "RelatedArtifact", name, element, index);
1594    if (element.hasTypeElement()) {
1595      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
1596    }
1597    for (int i = 0; i < element.getClassifier().size(); i++) {
1598      composeCodeableConcept(t, "RelatedArtifact", "classifier", element.getClassifier().get(i), i);
1599    }
1600    if (element.hasLabelElement()) {
1601      composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1);
1602    }
1603    if (element.hasDisplayElement()) {
1604      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
1605    }
1606    if (element.hasCitationElement()) {
1607      composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
1608    }
1609    if (element.hasDocument()) {
1610      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
1611    }
1612    if (element.hasResourceElement()) {
1613      composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1);
1614    }
1615    if (element.hasResourceReference()) {
1616      composeReference(t, "RelatedArtifact", "resourceReference", element.getResourceReference(), -1);
1617    }
1618    if (element.hasPublicationStatusElement()) {
1619      composeEnum(t, "RelatedArtifact", "publicationStatus", element.getPublicationStatusElement(), -1);
1620    }
1621    if (element.hasPublicationDateElement()) {
1622      composeDate(t, "RelatedArtifact", "publicationDate", element.getPublicationDateElement(), -1);
1623    }
1624  }
1625
1626  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
1627    if (element == null) 
1628      return;
1629    Complex t;
1630    if (Utilities.noString(parentType))
1631      t = parent;
1632    else {
1633      t = parent.predicate("fhir:"+name,index > -1);
1634    }
1635    composeDataType(t, "SampledData", name, element, index);
1636    if (element.hasOrigin()) {
1637      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
1638    }
1639    if (element.hasIntervalElement()) {
1640      composeDecimal(t, "SampledData", "interval", element.getIntervalElement(), -1);
1641    }
1642    if (element.hasIntervalUnitElement()) {
1643      composeCode(t, "SampledData", "intervalUnit", element.getIntervalUnitElement(), -1);
1644    }
1645    if (element.hasFactorElement()) {
1646      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
1647    }
1648    if (element.hasLowerLimitElement()) {
1649      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
1650    }
1651    if (element.hasUpperLimitElement()) {
1652      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
1653    }
1654    if (element.hasDimensionsElement()) {
1655      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
1656    }
1657    if (element.hasCodeMapElement()) {
1658      composeCanonical(t, "SampledData", "codeMap", element.getCodeMapElement(), -1);
1659    }
1660    if (element.hasOffsetsElement()) {
1661      composeString(t, "SampledData", "offsets", element.getOffsetsElement(), -1);
1662    }
1663    if (element.hasDataElement()) {
1664      composeString(t, "SampledData", "data", element.getDataElement(), -1);
1665    }
1666  }
1667
1668  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
1669    if (element == null) 
1670      return;
1671    Complex t;
1672    if (Utilities.noString(parentType))
1673      t = parent;
1674    else {
1675      t = parent.predicate("fhir:"+name,index > -1);
1676    }
1677    composeDataType(t, "Signature", name, element, index);
1678    for (int i = 0; i < element.getType().size(); i++) {
1679      composeCoding(t, "Signature", "type", element.getType().get(i), i);
1680    }
1681    if (element.hasWhenElement()) {
1682      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
1683    }
1684    if (element.hasWho()) {
1685      composeReference(t, "Signature", "who", element.getWho(), -1);
1686    }
1687    if (element.hasOnBehalfOf()) {
1688      composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
1689    }
1690    if (element.hasTargetFormatElement()) {
1691      composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1);
1692    }
1693    if (element.hasSigFormatElement()) {
1694      composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1);
1695    }
1696    if (element.hasDataElement()) {
1697      composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1);
1698    }
1699  }
1700
1701  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
1702    if (element == null) 
1703      return;
1704    Complex t;
1705    if (Utilities.noString(parentType))
1706      t = parent;
1707    else {
1708      t = parent.predicate("fhir:"+name,index > -1);
1709    }
1710    composeBackboneType(t, "Timing", name, element, index);
1711    for (int i = 0; i < element.getEvent().size(); i++) {
1712      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
1713    }
1714    if (element.hasRepeat()) {
1715      composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
1716    }
1717    if (element.hasCode()) {
1718      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
1719    }
1720  }
1721
1722  protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
1723    if (element == null) 
1724      return;
1725    Complex t;
1726    if (Utilities.noString(parentType))
1727      t = parent;
1728    else {
1729      t = parent.predicate("fhir:"+name,index > -1);
1730    }
1731    composeElement(t, "repeat", name, element, index);
1732    if (element.hasBounds()) {
1733      composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1);
1734    }
1735    if (element.hasCountElement()) {
1736      composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1);
1737    }
1738    if (element.hasCountMaxElement()) {
1739      composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1);
1740    }
1741    if (element.hasDurationElement()) {
1742      composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1);
1743    }
1744    if (element.hasDurationMaxElement()) {
1745      composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1);
1746    }
1747    if (element.hasDurationUnitElement()) {
1748      composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1);
1749    }
1750    if (element.hasFrequencyElement()) {
1751      composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1);
1752    }
1753    if (element.hasFrequencyMaxElement()) {
1754      composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1);
1755    }
1756    if (element.hasPeriodElement()) {
1757      composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1);
1758    }
1759    if (element.hasPeriodMaxElement()) {
1760      composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1);
1761    }
1762    if (element.hasPeriodUnitElement()) {
1763      composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1);
1764    }
1765    for (int i = 0; i < element.getDayOfWeek().size(); i++) {
1766      composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i);
1767    }
1768    for (int i = 0; i < element.getTimeOfDay().size(); i++) {
1769      composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i);
1770    }
1771    for (int i = 0; i < element.getWhen().size(); i++) {
1772      composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i);
1773    }
1774    if (element.hasOffsetElement()) {
1775      composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1);
1776    }
1777  }
1778
1779  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
1780    if (element == null) 
1781      return;
1782    Complex t;
1783    if (Utilities.noString(parentType))
1784      t = parent;
1785    else {
1786      t = parent.predicate("fhir:"+name,index > -1);
1787    }
1788    composeDataType(t, "TriggerDefinition", name, element, index);
1789    if (element.hasTypeElement()) {
1790      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
1791    }
1792    if (element.hasNameElement()) {
1793      composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1);
1794    }
1795    if (element.hasCode()) {
1796      composeCodeableConcept(t, "TriggerDefinition", "code", element.getCode(), -1);
1797    }
1798    if (element.hasSubscriptionTopicElement()) {
1799      composeCanonical(t, "TriggerDefinition", "subscriptionTopic", element.getSubscriptionTopicElement(), -1);
1800    }
1801    if (element.hasTiming()) {
1802      composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1);
1803    }
1804    for (int i = 0; i < element.getData().size(); i++) {
1805      composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i);
1806    }
1807    if (element.hasCondition()) {
1808      composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1);
1809    }
1810  }
1811
1812  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
1813    if (element == null) 
1814      return;
1815    Complex t;
1816    if (Utilities.noString(parentType))
1817      t = parent;
1818    else {
1819      t = parent.predicate("fhir:"+name,index > -1);
1820    }
1821    composeDataType(t, "UsageContext", name, element, index);
1822    if (element.hasCode()) {
1823      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
1824    }
1825    if (element.hasValue()) {
1826      composeType(t, "UsageContext", "value", element.getValue(), -1);
1827    }
1828  }
1829
1830  protected void composeVirtualServiceDetail(Complex parent, String parentType, String name, VirtualServiceDetail element, int index) {
1831    if (element == null) 
1832      return;
1833    Complex t;
1834    if (Utilities.noString(parentType))
1835      t = parent;
1836    else {
1837      t = parent.predicate("fhir:"+name,index > -1);
1838    }
1839    composeDataType(t, "VirtualServiceDetail", name, element, index);
1840    if (element.hasChannelType()) {
1841      composeCoding(t, "VirtualServiceDetail", "channelType", element.getChannelType(), -1);
1842    }
1843    if (element.hasAddress()) {
1844      composeType(t, "VirtualServiceDetail", "address", element.getAddress(), -1);
1845    }
1846    for (int i = 0; i < element.getAdditionalInfo().size(); i++) {
1847      composeUrl(t, "VirtualServiceDetail", "additionalInfo", element.getAdditionalInfo().get(i), i);
1848    }
1849    if (element.hasMaxParticipantsElement()) {
1850      composePositiveInt(t, "VirtualServiceDetail", "maxParticipants", element.getMaxParticipantsElement(), -1);
1851    }
1852    if (element.hasSessionKeyElement()) {
1853      composeString(t, "VirtualServiceDetail", "sessionKey", element.getSessionKeyElement(), -1);
1854    }
1855  }
1856
1857  protected void composeCanonicalResource(Complex t, String parentType, String name, CanonicalResource element, int index) {
1858    composeDomainResource(t, parentType, name, element, index);
1859    if (element.hasUrlElement()) {
1860      composeUri(t, "CanonicalResource", "url", element.getUrlElement(), -1);
1861    }
1862    for (int i = 0; i < element.getIdentifier().size(); i++) {
1863      composeIdentifier(t, "CanonicalResource", "identifier", element.getIdentifier().get(i), i);
1864    }
1865    if (element.hasVersionElement()) {
1866      composeString(t, "CanonicalResource", "version", element.getVersionElement(), -1);
1867    }
1868    if (element.hasVersionAlgorithm()) {
1869      composeType(t, "CanonicalResource", "versionAlgorithm", element.getVersionAlgorithm(), -1);
1870    }
1871    if (element.hasNameElement()) {
1872      composeString(t, "CanonicalResource", "name", element.getNameElement(), -1);
1873    }
1874    if (element.hasTitleElement()) {
1875      composeString(t, "CanonicalResource", "title", element.getTitleElement(), -1);
1876    }
1877    if (element.hasStatusElement()) {
1878      composeEnum(t, "CanonicalResource", "status", element.getStatusElement(), -1);
1879    }
1880    if (element.hasExperimentalElement()) {
1881      composeBoolean(t, "CanonicalResource", "experimental", element.getExperimentalElement(), -1);
1882    }
1883    if (element.hasDateElement()) {
1884      composeDateTime(t, "CanonicalResource", "date", element.getDateElement(), -1);
1885    }
1886    if (element.hasPublisherElement()) {
1887      composeString(t, "CanonicalResource", "publisher", element.getPublisherElement(), -1);
1888    }
1889    for (int i = 0; i < element.getContact().size(); i++) {
1890      composeContactDetail(t, "CanonicalResource", "contact", element.getContact().get(i), i);
1891    }
1892    if (element.hasDescriptionElement()) {
1893      composeMarkdown(t, "CanonicalResource", "description", element.getDescriptionElement(), -1);
1894    }
1895    for (int i = 0; i < element.getUseContext().size(); i++) {
1896      composeUsageContext(t, "CanonicalResource", "useContext", element.getUseContext().get(i), i);
1897    }
1898    for (int i = 0; i < element.getJurisdiction().size(); i++) {
1899      composeCodeableConcept(t, "CanonicalResource", "jurisdiction", element.getJurisdiction().get(i), i);
1900    }
1901    if (element.hasPurposeElement()) {
1902      composeMarkdown(t, "CanonicalResource", "purpose", element.getPurposeElement(), -1);
1903    }
1904    if (element.hasCopyrightElement()) {
1905      composeMarkdown(t, "CanonicalResource", "copyright", element.getCopyrightElement(), -1);
1906    }
1907    if (element.hasCopyrightLabelElement()) {
1908      composeString(t, "CanonicalResource", "copyrightLabel", element.getCopyrightLabelElement(), -1);
1909    }
1910  }
1911
1912  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
1913    composeResource(t, parentType, name, element, index);
1914    if (element.hasText()) {
1915      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
1916    }
1917    for (int i = 0; i < element.getContained().size(); i++) {
1918      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
1919    }
1920    for (int i = 0; i < element.getExtension().size(); i++) {
1921      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
1922    }
1923    for (int i = 0; i < element.getModifierExtension().size(); i++) {
1924      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
1925    }
1926  }
1927
1928  protected void composeMetadataResource(Complex t, String parentType, String name, MetadataResource element, int index) {
1929    composeCanonicalResource(t, parentType, name, element, index);
1930    if (element.hasApprovalDateElement()) {
1931      composeDate(t, "MetadataResource", "approvalDate", element.getApprovalDateElement(), -1);
1932    }
1933    if (element.hasLastReviewDateElement()) {
1934      composeDate(t, "MetadataResource", "lastReviewDate", element.getLastReviewDateElement(), -1);
1935    }
1936    if (element.hasEffectivePeriod()) {
1937      composePeriod(t, "MetadataResource", "effectivePeriod", element.getEffectivePeriod(), -1);
1938    }
1939    for (int i = 0; i < element.getTopic().size(); i++) {
1940      composeCodeableConcept(t, "MetadataResource", "topic", element.getTopic().get(i), i);
1941    }
1942    for (int i = 0; i < element.getAuthor().size(); i++) {
1943      composeContactDetail(t, "MetadataResource", "author", element.getAuthor().get(i), i);
1944    }
1945    for (int i = 0; i < element.getEditor().size(); i++) {
1946      composeContactDetail(t, "MetadataResource", "editor", element.getEditor().get(i), i);
1947    }
1948    for (int i = 0; i < element.getReviewer().size(); i++) {
1949      composeContactDetail(t, "MetadataResource", "reviewer", element.getReviewer().get(i), i);
1950    }
1951    for (int i = 0; i < element.getEndorser().size(); i++) {
1952      composeContactDetail(t, "MetadataResource", "endorser", element.getEndorser().get(i), i);
1953    }
1954    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
1955      composeRelatedArtifact(t, "MetadataResource", "relatedArtifact", element.getRelatedArtifact().get(i), i);
1956    }
1957  }
1958
1959  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
1960    composeBase(t, parentType, name, element, index);
1961    if (element.hasIdElement()) {
1962      composeId(t, "Resource", "id", element.getIdElement(), -1);
1963    }
1964    if (element.hasMeta()) {
1965      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
1966    }
1967    if (element.hasImplicitRulesElement()) {
1968      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
1969    }
1970    if (element.hasLanguageElement()) {
1971      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
1972    }
1973  }
1974
1975  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
1976    if (element == null) 
1977      return;
1978    Complex t;
1979    if (Utilities.noString(parentType))
1980      t = parent;
1981    else {
1982      t = parent.predicate("fhir:"+name,index > -1);
1983    }
1984    composeDomainResource(t, "Account", name, element, index);
1985    for (int i = 0; i < element.getIdentifier().size(); i++) {
1986      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
1987    }
1988    if (element.hasStatusElement()) {
1989      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
1990    }
1991    if (element.hasBillingStatus()) {
1992      composeCodeableConcept(t, "Account", "billingStatus", element.getBillingStatus(), -1);
1993    }
1994    if (element.hasType()) {
1995      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
1996    }
1997    if (element.hasNameElement()) {
1998      composeString(t, "Account", "name", element.getNameElement(), -1);
1999    }
2000    for (int i = 0; i < element.getSubject().size(); i++) {
2001      composeReference(t, "Account", "subject", element.getSubject().get(i), i);
2002    }
2003    if (element.hasServicePeriod()) {
2004      composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1);
2005    }
2006    for (int i = 0; i < element.getCoverage().size(); i++) {
2007      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
2008    }
2009    if (element.hasOwner()) {
2010      composeReference(t, "Account", "owner", element.getOwner(), -1);
2011    }
2012    if (element.hasDescriptionElement()) {
2013      composeMarkdown(t, "Account", "description", element.getDescriptionElement(), -1);
2014    }
2015    for (int i = 0; i < element.getGuarantor().size(); i++) {
2016      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
2017    }
2018    for (int i = 0; i < element.getDiagnosis().size(); i++) {
2019      composeAccountDiagnosisComponent(t, "Account", "diagnosis", element.getDiagnosis().get(i), i);
2020    }
2021    for (int i = 0; i < element.getProcedure().size(); i++) {
2022      composeAccountProcedureComponent(t, "Account", "procedure", element.getProcedure().get(i), i);
2023    }
2024    for (int i = 0; i < element.getRelatedAccount().size(); i++) {
2025      composeAccountRelatedAccountComponent(t, "Account", "relatedAccount", element.getRelatedAccount().get(i), i);
2026    }
2027    if (element.hasCurrency()) {
2028      composeCodeableConcept(t, "Account", "currency", element.getCurrency(), -1);
2029    }
2030    for (int i = 0; i < element.getBalance().size(); i++) {
2031      composeAccountBalanceComponent(t, "Account", "balance", element.getBalance().get(i), i);
2032    }
2033    if (element.hasCalculatedAtElement()) {
2034      composeInstant(t, "Account", "calculatedAt", element.getCalculatedAtElement(), -1);
2035    }
2036  }
2037
2038  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
2039    if (element == null) 
2040      return;
2041    Complex t;
2042    if (Utilities.noString(parentType))
2043      t = parent;
2044    else {
2045      t = parent.predicate("fhir:"+name,index > -1);
2046    }
2047    composeBackboneElement(t, "coverage", name, element, index);
2048    if (element.hasCoverage()) {
2049      composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1);
2050    }
2051    if (element.hasPriorityElement()) {
2052      composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1);
2053    }
2054  }
2055
2056  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
2057    if (element == null) 
2058      return;
2059    Complex t;
2060    if (Utilities.noString(parentType))
2061      t = parent;
2062    else {
2063      t = parent.predicate("fhir:"+name,index > -1);
2064    }
2065    composeBackboneElement(t, "guarantor", name, element, index);
2066    if (element.hasParty()) {
2067      composeReference(t, "GuarantorComponent", "party", element.getParty(), -1);
2068    }
2069    if (element.hasOnHoldElement()) {
2070      composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1);
2071    }
2072    if (element.hasPeriod()) {
2073      composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1);
2074    }
2075  }
2076
2077  protected void composeAccountDiagnosisComponent(Complex parent, String parentType, String name, Account.AccountDiagnosisComponent element, int index) {
2078    if (element == null) 
2079      return;
2080    Complex t;
2081    if (Utilities.noString(parentType))
2082      t = parent;
2083    else {
2084      t = parent.predicate("fhir:"+name,index > -1);
2085    }
2086    composeBackboneElement(t, "diagnosis", name, element, index);
2087    if (element.hasSequenceElement()) {
2088      composePositiveInt(t, "AccountDiagnosisComponent", "sequence", element.getSequenceElement(), -1);
2089    }
2090    if (element.hasCondition()) {
2091      composeCodeableReference(t, "AccountDiagnosisComponent", "condition", element.getCondition(), -1);
2092    }
2093    if (element.hasDateOfDiagnosisElement()) {
2094      composeDateTime(t, "AccountDiagnosisComponent", "dateOfDiagnosis", element.getDateOfDiagnosisElement(), -1);
2095    }
2096    for (int i = 0; i < element.getType().size(); i++) {
2097      composeCodeableConcept(t, "AccountDiagnosisComponent", "type", element.getType().get(i), i);
2098    }
2099    if (element.hasOnAdmissionElement()) {
2100      composeBoolean(t, "AccountDiagnosisComponent", "onAdmission", element.getOnAdmissionElement(), -1);
2101    }
2102    for (int i = 0; i < element.getPackageCode().size(); i++) {
2103      composeCodeableConcept(t, "AccountDiagnosisComponent", "packageCode", element.getPackageCode().get(i), i);
2104    }
2105  }
2106
2107  protected void composeAccountProcedureComponent(Complex parent, String parentType, String name, Account.AccountProcedureComponent element, int index) {
2108    if (element == null) 
2109      return;
2110    Complex t;
2111    if (Utilities.noString(parentType))
2112      t = parent;
2113    else {
2114      t = parent.predicate("fhir:"+name,index > -1);
2115    }
2116    composeBackboneElement(t, "procedure", name, element, index);
2117    if (element.hasSequenceElement()) {
2118      composePositiveInt(t, "AccountProcedureComponent", "sequence", element.getSequenceElement(), -1);
2119    }
2120    if (element.hasCode()) {
2121      composeCodeableReference(t, "AccountProcedureComponent", "code", element.getCode(), -1);
2122    }
2123    if (element.hasDateOfServiceElement()) {
2124      composeDateTime(t, "AccountProcedureComponent", "dateOfService", element.getDateOfServiceElement(), -1);
2125    }
2126    for (int i = 0; i < element.getType().size(); i++) {
2127      composeCodeableConcept(t, "AccountProcedureComponent", "type", element.getType().get(i), i);
2128    }
2129    for (int i = 0; i < element.getPackageCode().size(); i++) {
2130      composeCodeableConcept(t, "AccountProcedureComponent", "packageCode", element.getPackageCode().get(i), i);
2131    }
2132    for (int i = 0; i < element.getDevice().size(); i++) {
2133      composeReference(t, "AccountProcedureComponent", "device", element.getDevice().get(i), i);
2134    }
2135  }
2136
2137  protected void composeAccountRelatedAccountComponent(Complex parent, String parentType, String name, Account.AccountRelatedAccountComponent element, int index) {
2138    if (element == null) 
2139      return;
2140    Complex t;
2141    if (Utilities.noString(parentType))
2142      t = parent;
2143    else {
2144      t = parent.predicate("fhir:"+name,index > -1);
2145    }
2146    composeBackboneElement(t, "relatedAccount", name, element, index);
2147    if (element.hasRelationship()) {
2148      composeCodeableConcept(t, "AccountRelatedAccountComponent", "relationship", element.getRelationship(), -1);
2149    }
2150    if (element.hasAccount()) {
2151      composeReference(t, "AccountRelatedAccountComponent", "account", element.getAccount(), -1);
2152    }
2153  }
2154
2155  protected void composeAccountBalanceComponent(Complex parent, String parentType, String name, Account.AccountBalanceComponent element, int index) {
2156    if (element == null) 
2157      return;
2158    Complex t;
2159    if (Utilities.noString(parentType))
2160      t = parent;
2161    else {
2162      t = parent.predicate("fhir:"+name,index > -1);
2163    }
2164    composeBackboneElement(t, "balance", name, element, index);
2165    if (element.hasAggregate()) {
2166      composeCodeableConcept(t, "AccountBalanceComponent", "aggregate", element.getAggregate(), -1);
2167    }
2168    if (element.hasTerm()) {
2169      composeCodeableConcept(t, "AccountBalanceComponent", "term", element.getTerm(), -1);
2170    }
2171    if (element.hasEstimateElement()) {
2172      composeBoolean(t, "AccountBalanceComponent", "estimate", element.getEstimateElement(), -1);
2173    }
2174    if (element.hasAmount()) {
2175      composeMoney(t, "AccountBalanceComponent", "amount", element.getAmount(), -1);
2176    }
2177  }
2178
2179  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) {
2180    if (element == null) 
2181      return;
2182    Complex t;
2183    if (Utilities.noString(parentType))
2184      t = parent;
2185    else {
2186      t = parent.predicate("fhir:"+name,index > -1);
2187    }
2188    composeMetadataResource(t, "ActivityDefinition", name, element, index);
2189    if (element.hasUrlElement()) {
2190      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
2191    }
2192    for (int i = 0; i < element.getIdentifier().size(); i++) {
2193      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
2194    }
2195    if (element.hasVersionElement()) {
2196      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
2197    }
2198    if (element.hasVersionAlgorithm()) {
2199      composeType(t, "ActivityDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
2200    }
2201    if (element.hasNameElement()) {
2202      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
2203    }
2204    if (element.hasTitleElement()) {
2205      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
2206    }
2207    if (element.hasSubtitleElement()) {
2208      composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1);
2209    }
2210    if (element.hasStatusElement()) {
2211      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
2212    }
2213    if (element.hasExperimentalElement()) {
2214      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
2215    }
2216    if (element.hasSubject()) {
2217      composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1);
2218    }
2219    if (element.hasDateElement()) {
2220      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
2221    }
2222    if (element.hasPublisherElement()) {
2223      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
2224    }
2225    for (int i = 0; i < element.getContact().size(); i++) {
2226      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
2227    }
2228    if (element.hasDescriptionElement()) {
2229      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
2230    }
2231    for (int i = 0; i < element.getUseContext().size(); i++) {
2232      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
2233    }
2234    for (int i = 0; i < element.getJurisdiction().size(); i++) {
2235      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
2236    }
2237    if (element.hasPurposeElement()) {
2238      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
2239    }
2240    if (element.hasUsageElement()) {
2241      composeMarkdown(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
2242    }
2243    if (element.hasCopyrightElement()) {
2244      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
2245    }
2246    if (element.hasCopyrightLabelElement()) {
2247      composeString(t, "ActivityDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
2248    }
2249    if (element.hasApprovalDateElement()) {
2250      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
2251    }
2252    if (element.hasLastReviewDateElement()) {
2253      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
2254    }
2255    if (element.hasEffectivePeriod()) {
2256      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
2257    }
2258    for (int i = 0; i < element.getTopic().size(); i++) {
2259      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
2260    }
2261    for (int i = 0; i < element.getAuthor().size(); i++) {
2262      composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i);
2263    }
2264    for (int i = 0; i < element.getEditor().size(); i++) {
2265      composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i);
2266    }
2267    for (int i = 0; i < element.getReviewer().size(); i++) {
2268      composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i);
2269    }
2270    for (int i = 0; i < element.getEndorser().size(); i++) {
2271      composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i);
2272    }
2273    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
2274      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
2275    }
2276    for (int i = 0; i < element.getLibrary().size(); i++) {
2277      composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
2278    }
2279    if (element.hasKindElement()) {
2280      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
2281    }
2282    if (element.hasProfileElement()) {
2283      composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1);
2284    }
2285    if (element.hasCode()) {
2286      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
2287    }
2288    if (element.hasIntentElement()) {
2289      composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1);
2290    }
2291    if (element.hasPriorityElement()) {
2292      composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1);
2293    }
2294    if (element.hasDoNotPerformElement()) {
2295      composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1);
2296    }
2297    if (element.hasTiming()) {
2298      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
2299    }
2300    if (element.hasAsNeeded()) {
2301      composeType(t, "ActivityDefinition", "asNeeded", element.getAsNeeded(), -1);
2302    }
2303    if (element.hasLocation()) {
2304      composeCodeableReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
2305    }
2306    for (int i = 0; i < element.getParticipant().size(); i++) {
2307      composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
2308    }
2309    if (element.hasProduct()) {
2310      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
2311    }
2312    if (element.hasQuantity()) {
2313      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
2314    }
2315    for (int i = 0; i < element.getDosage().size(); i++) {
2316      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
2317    }
2318    for (int i = 0; i < element.getBodySite().size(); i++) {
2319      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
2320    }
2321    for (int i = 0; i < element.getSpecimenRequirement().size(); i++) {
2322      composeCanonical(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i);
2323    }
2324    for (int i = 0; i < element.getObservationRequirement().size(); i++) {
2325      composeCanonical(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i);
2326    }
2327    for (int i = 0; i < element.getObservationResultRequirement().size(); i++) {
2328      composeCanonical(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i);
2329    }
2330    if (element.hasTransformElement()) {
2331      composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1);
2332    }
2333    for (int i = 0; i < element.getDynamicValue().size(); i++) {
2334      composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
2335    }
2336  }
2337
2338  protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
2339    if (element == null) 
2340      return;
2341    Complex t;
2342    if (Utilities.noString(parentType))
2343      t = parent;
2344    else {
2345      t = parent.predicate("fhir:"+name,index > -1);
2346    }
2347    composeBackboneElement(t, "participant", name, element, index);
2348    if (element.hasTypeElement()) {
2349      composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1);
2350    }
2351    if (element.hasTypeCanonicalElement()) {
2352      composeCanonical(t, "ActivityDefinitionParticipantComponent", "typeCanonical", element.getTypeCanonicalElement(), -1);
2353    }
2354    if (element.hasTypeReference()) {
2355      composeReference(t, "ActivityDefinitionParticipantComponent", "typeReference", element.getTypeReference(), -1);
2356    }
2357    if (element.hasRole()) {
2358      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1);
2359    }
2360    if (element.hasFunction()) {
2361      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "function", element.getFunction(), -1);
2362    }
2363  }
2364
2365  protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
2366    if (element == null) 
2367      return;
2368    Complex t;
2369    if (Utilities.noString(parentType))
2370      t = parent;
2371    else {
2372      t = parent.predicate("fhir:"+name,index > -1);
2373    }
2374    composeBackboneElement(t, "dynamicValue", name, element, index);
2375    if (element.hasPathElement()) {
2376      composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1);
2377    }
2378    if (element.hasExpression()) {
2379      composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1);
2380    }
2381  }
2382
2383  protected void composeActorDefinition(Complex parent, String parentType, String name, ActorDefinition element, int index) {
2384    if (element == null) 
2385      return;
2386    Complex t;
2387    if (Utilities.noString(parentType))
2388      t = parent;
2389    else {
2390      t = parent.predicate("fhir:"+name,index > -1);
2391    }
2392    composeCanonicalResource(t, "ActorDefinition", name, element, index);
2393    if (element.hasUrlElement()) {
2394      composeUri(t, "ActorDefinition", "url", element.getUrlElement(), -1);
2395    }
2396    for (int i = 0; i < element.getIdentifier().size(); i++) {
2397      composeIdentifier(t, "ActorDefinition", "identifier", element.getIdentifier().get(i), i);
2398    }
2399    if (element.hasVersionElement()) {
2400      composeString(t, "ActorDefinition", "version", element.getVersionElement(), -1);
2401    }
2402    if (element.hasVersionAlgorithm()) {
2403      composeType(t, "ActorDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
2404    }
2405    if (element.hasNameElement()) {
2406      composeString(t, "ActorDefinition", "name", element.getNameElement(), -1);
2407    }
2408    if (element.hasTitleElement()) {
2409      composeString(t, "ActorDefinition", "title", element.getTitleElement(), -1);
2410    }
2411    if (element.hasStatusElement()) {
2412      composeEnum(t, "ActorDefinition", "status", element.getStatusElement(), -1);
2413    }
2414    if (element.hasExperimentalElement()) {
2415      composeBoolean(t, "ActorDefinition", "experimental", element.getExperimentalElement(), -1);
2416    }
2417    if (element.hasDateElement()) {
2418      composeDateTime(t, "ActorDefinition", "date", element.getDateElement(), -1);
2419    }
2420    if (element.hasPublisherElement()) {
2421      composeString(t, "ActorDefinition", "publisher", element.getPublisherElement(), -1);
2422    }
2423    for (int i = 0; i < element.getContact().size(); i++) {
2424      composeContactDetail(t, "ActorDefinition", "contact", element.getContact().get(i), i);
2425    }
2426    if (element.hasDescriptionElement()) {
2427      composeMarkdown(t, "ActorDefinition", "description", element.getDescriptionElement(), -1);
2428    }
2429    for (int i = 0; i < element.getUseContext().size(); i++) {
2430      composeUsageContext(t, "ActorDefinition", "useContext", element.getUseContext().get(i), i);
2431    }
2432    for (int i = 0; i < element.getJurisdiction().size(); i++) {
2433      composeCodeableConcept(t, "ActorDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
2434    }
2435    if (element.hasPurposeElement()) {
2436      composeMarkdown(t, "ActorDefinition", "purpose", element.getPurposeElement(), -1);
2437    }
2438    if (element.hasCopyrightElement()) {
2439      composeMarkdown(t, "ActorDefinition", "copyright", element.getCopyrightElement(), -1);
2440    }
2441    if (element.hasCopyrightLabelElement()) {
2442      composeString(t, "ActorDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
2443    }
2444    if (element.hasTypeElement()) {
2445      composeEnum(t, "ActorDefinition", "type", element.getTypeElement(), -1);
2446    }
2447    if (element.hasDocumentationElement()) {
2448      composeMarkdown(t, "ActorDefinition", "documentation", element.getDocumentationElement(), -1);
2449    }
2450    for (int i = 0; i < element.getReference().size(); i++) {
2451      composeUrl(t, "ActorDefinition", "reference", element.getReference().get(i), i);
2452    }
2453    if (element.hasCapabilitiesElement()) {
2454      composeCanonical(t, "ActorDefinition", "capabilities", element.getCapabilitiesElement(), -1);
2455    }
2456    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
2457      composeCanonical(t, "ActorDefinition", "derivedFrom", element.getDerivedFrom().get(i), i);
2458    }
2459  }
2460
2461  protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) {
2462    if (element == null) 
2463      return;
2464    Complex t;
2465    if (Utilities.noString(parentType))
2466      t = parent;
2467    else {
2468      t = parent.predicate("fhir:"+name,index > -1);
2469    }
2470    composeDomainResource(t, "AdministrableProductDefinition", name, element, index);
2471    for (int i = 0; i < element.getIdentifier().size(); i++) {
2472      composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i);
2473    }
2474    if (element.hasStatusElement()) {
2475      composeEnum(t, "AdministrableProductDefinition", "status", element.getStatusElement(), -1);
2476    }
2477    for (int i = 0; i < element.getFormOf().size(); i++) {
2478      composeReference(t, "AdministrableProductDefinition", "formOf", element.getFormOf().get(i), i);
2479    }
2480    if (element.hasAdministrableDoseForm()) {
2481      composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1);
2482    }
2483    if (element.hasUnitOfPresentation()) {
2484      composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
2485    }
2486    for (int i = 0; i < element.getProducedFrom().size(); i++) {
2487      composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i);
2488    }
2489    for (int i = 0; i < element.getIngredient().size(); i++) {
2490      composeCodeableConcept(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i);
2491    }
2492    if (element.hasDevice()) {
2493      composeReference(t, "AdministrableProductDefinition", "device", element.getDevice(), -1);
2494    }
2495    if (element.hasDescriptionElement()) {
2496      composeMarkdown(t, "AdministrableProductDefinition", "description", element.getDescriptionElement(), -1);
2497    }
2498    for (int i = 0; i < element.getProperty().size(); i++) {
2499      composeAdministrableProductDefinitionPropertyComponent(t, "AdministrableProductDefinition", "property", element.getProperty().get(i), i);
2500    }
2501    for (int i = 0; i < element.getRouteOfAdministration().size(); i++) {
2502      composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i);
2503    }
2504  }
2505
2506  protected void composeAdministrableProductDefinitionPropertyComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent element, int index) {
2507    if (element == null) 
2508      return;
2509    Complex t;
2510    if (Utilities.noString(parentType))
2511      t = parent;
2512    else {
2513      t = parent.predicate("fhir:"+name,index > -1);
2514    }
2515    composeBackboneElement(t, "property", name, element, index);
2516    if (element.hasType()) {
2517      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "type", element.getType(), -1);
2518    }
2519    if (element.hasValue()) {
2520      composeType(t, "AdministrableProductDefinitionPropertyComponent", "value", element.getValue(), -1);
2521    }
2522    if (element.hasStatus()) {
2523      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "status", element.getStatus(), -1);
2524    }
2525  }
2526
2527  protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) {
2528    if (element == null) 
2529      return;
2530    Complex t;
2531    if (Utilities.noString(parentType))
2532      t = parent;
2533    else {
2534      t = parent.predicate("fhir:"+name,index > -1);
2535    }
2536    composeBackboneElement(t, "routeOfAdministration", name, element, index);
2537    if (element.hasCode()) {
2538      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1);
2539    }
2540    if (element.hasFirstDose()) {
2541      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1);
2542    }
2543    if (element.hasMaxSingleDose()) {
2544      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1);
2545    }
2546    if (element.hasMaxDosePerDay()) {
2547      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1);
2548    }
2549    if (element.hasMaxDosePerTreatmentPeriod()) {
2550      composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1);
2551    }
2552    if (element.hasMaxTreatmentPeriod()) {
2553      composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1);
2554    }
2555    for (int i = 0; i < element.getTargetSpecies().size(); i++) {
2556      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i);
2557    }
2558  }
2559
2560  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) {
2561    if (element == null) 
2562      return;
2563    Complex t;
2564    if (Utilities.noString(parentType))
2565      t = parent;
2566    else {
2567      t = parent.predicate("fhir:"+name,index > -1);
2568    }
2569    composeBackboneElement(t, "targetSpecies", name, element, index);
2570    if (element.hasCode()) {
2571      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1);
2572    }
2573    for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) {
2574      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i);
2575    }
2576  }
2577
2578  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) {
2579    if (element == null) 
2580      return;
2581    Complex t;
2582    if (Utilities.noString(parentType))
2583      t = parent;
2584    else {
2585      t = parent.predicate("fhir:"+name,index > -1);
2586    }
2587    composeBackboneElement(t, "withdrawalPeriod", name, element, index);
2588    if (element.hasTissue()) {
2589      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1);
2590    }
2591    if (element.hasValue()) {
2592      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1);
2593    }
2594    if (element.hasSupportingInformationElement()) {
2595      composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1);
2596    }
2597  }
2598
2599  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
2600    if (element == null) 
2601      return;
2602    Complex t;
2603    if (Utilities.noString(parentType))
2604      t = parent;
2605    else {
2606      t = parent.predicate("fhir:"+name,index > -1);
2607    }
2608    composeDomainResource(t, "AdverseEvent", name, element, index);
2609    for (int i = 0; i < element.getIdentifier().size(); i++) {
2610      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier().get(i), i);
2611    }
2612    if (element.hasStatusElement()) {
2613      composeEnum(t, "AdverseEvent", "status", element.getStatusElement(), -1);
2614    }
2615    if (element.hasActualityElement()) {
2616      composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1);
2617    }
2618    for (int i = 0; i < element.getCategory().size(); i++) {
2619      composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i);
2620    }
2621    if (element.hasCode()) {
2622      composeCodeableConcept(t, "AdverseEvent", "code", element.getCode(), -1);
2623    }
2624    if (element.hasSubject()) {
2625      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
2626    }
2627    if (element.hasEncounter()) {
2628      composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1);
2629    }
2630    if (element.hasOccurrence()) {
2631      composeType(t, "AdverseEvent", "occurrence", element.getOccurrence(), -1);
2632    }
2633    if (element.hasDetectedElement()) {
2634      composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1);
2635    }
2636    if (element.hasRecordedDateElement()) {
2637      composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1);
2638    }
2639    for (int i = 0; i < element.getResultingEffect().size(); i++) {
2640      composeReference(t, "AdverseEvent", "resultingEffect", element.getResultingEffect().get(i), i);
2641    }
2642    if (element.hasLocation()) {
2643      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
2644    }
2645    if (element.hasSeriousness()) {
2646      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
2647    }
2648    for (int i = 0; i < element.getOutcome().size(); i++) {
2649      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome().get(i), i);
2650    }
2651    if (element.hasRecorder()) {
2652      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
2653    }
2654    for (int i = 0; i < element.getParticipant().size(); i++) {
2655      composeAdverseEventParticipantComponent(t, "AdverseEvent", "participant", element.getParticipant().get(i), i);
2656    }
2657    for (int i = 0; i < element.getStudy().size(); i++) {
2658      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
2659    }
2660    if (element.hasExpectedInResearchStudyElement()) {
2661      composeBoolean(t, "AdverseEvent", "expectedInResearchStudy", element.getExpectedInResearchStudyElement(), -1);
2662    }
2663    for (int i = 0; i < element.getSuspectEntity().size(); i++) {
2664      composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
2665    }
2666    for (int i = 0; i < element.getContributingFactor().size(); i++) {
2667      composeAdverseEventContributingFactorComponent(t, "AdverseEvent", "contributingFactor", element.getContributingFactor().get(i), i);
2668    }
2669    for (int i = 0; i < element.getPreventiveAction().size(); i++) {
2670      composeAdverseEventPreventiveActionComponent(t, "AdverseEvent", "preventiveAction", element.getPreventiveAction().get(i), i);
2671    }
2672    for (int i = 0; i < element.getMitigatingAction().size(); i++) {
2673      composeAdverseEventMitigatingActionComponent(t, "AdverseEvent", "mitigatingAction", element.getMitigatingAction().get(i), i);
2674    }
2675    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
2676      composeAdverseEventSupportingInfoComponent(t, "AdverseEvent", "supportingInfo", element.getSupportingInfo().get(i), i);
2677    }
2678    for (int i = 0; i < element.getNote().size(); i++) {
2679      composeAnnotation(t, "AdverseEvent", "note", element.getNote().get(i), i);
2680    }
2681  }
2682
2683  protected void composeAdverseEventParticipantComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventParticipantComponent element, int index) {
2684    if (element == null) 
2685      return;
2686    Complex t;
2687    if (Utilities.noString(parentType))
2688      t = parent;
2689    else {
2690      t = parent.predicate("fhir:"+name,index > -1);
2691    }
2692    composeBackboneElement(t, "participant", name, element, index);
2693    if (element.hasFunction()) {
2694      composeCodeableConcept(t, "AdverseEventParticipantComponent", "function", element.getFunction(), -1);
2695    }
2696    if (element.hasActor()) {
2697      composeReference(t, "AdverseEventParticipantComponent", "actor", element.getActor(), -1);
2698    }
2699  }
2700
2701  protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) {
2702    if (element == null) 
2703      return;
2704    Complex t;
2705    if (Utilities.noString(parentType))
2706      t = parent;
2707    else {
2708      t = parent.predicate("fhir:"+name,index > -1);
2709    }
2710    composeBackboneElement(t, "suspectEntity", name, element, index);
2711    if (element.hasInstance()) {
2712      composeType(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1);
2713    }
2714    if (element.hasCausality()) {
2715      composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality(), -1);
2716    }
2717  }
2718
2719  protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) {
2720    if (element == null) 
2721      return;
2722    Complex t;
2723    if (Utilities.noString(parentType))
2724      t = parent;
2725    else {
2726      t = parent.predicate("fhir:"+name,index > -1);
2727    }
2728    composeBackboneElement(t, "causality", name, element, index);
2729    if (element.hasAssessmentMethod()) {
2730      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessmentMethod", element.getAssessmentMethod(), -1);
2731    }
2732    if (element.hasEntityRelatedness()) {
2733      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "entityRelatedness", element.getEntityRelatedness(), -1);
2734    }
2735    if (element.hasAuthor()) {
2736      composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1);
2737    }
2738  }
2739
2740  protected void composeAdverseEventContributingFactorComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventContributingFactorComponent element, int index) {
2741    if (element == null) 
2742      return;
2743    Complex t;
2744    if (Utilities.noString(parentType))
2745      t = parent;
2746    else {
2747      t = parent.predicate("fhir:"+name,index > -1);
2748    }
2749    composeBackboneElement(t, "contributingFactor", name, element, index);
2750    if (element.hasItem()) {
2751      composeType(t, "AdverseEventContributingFactorComponent", "item", element.getItem(), -1);
2752    }
2753  }
2754
2755  protected void composeAdverseEventPreventiveActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventPreventiveActionComponent element, int index) {
2756    if (element == null) 
2757      return;
2758    Complex t;
2759    if (Utilities.noString(parentType))
2760      t = parent;
2761    else {
2762      t = parent.predicate("fhir:"+name,index > -1);
2763    }
2764    composeBackboneElement(t, "preventiveAction", name, element, index);
2765    if (element.hasItem()) {
2766      composeType(t, "AdverseEventPreventiveActionComponent", "item", element.getItem(), -1);
2767    }
2768  }
2769
2770  protected void composeAdverseEventMitigatingActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventMitigatingActionComponent element, int index) {
2771    if (element == null) 
2772      return;
2773    Complex t;
2774    if (Utilities.noString(parentType))
2775      t = parent;
2776    else {
2777      t = parent.predicate("fhir:"+name,index > -1);
2778    }
2779    composeBackboneElement(t, "mitigatingAction", name, element, index);
2780    if (element.hasItem()) {
2781      composeType(t, "AdverseEventMitigatingActionComponent", "item", element.getItem(), -1);
2782    }
2783  }
2784
2785  protected void composeAdverseEventSupportingInfoComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSupportingInfoComponent element, int index) {
2786    if (element == null) 
2787      return;
2788    Complex t;
2789    if (Utilities.noString(parentType))
2790      t = parent;
2791    else {
2792      t = parent.predicate("fhir:"+name,index > -1);
2793    }
2794    composeBackboneElement(t, "supportingInfo", name, element, index);
2795    if (element.hasItem()) {
2796      composeType(t, "AdverseEventSupportingInfoComponent", "item", element.getItem(), -1);
2797    }
2798  }
2799
2800  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
2801    if (element == null) 
2802      return;
2803    Complex t;
2804    if (Utilities.noString(parentType))
2805      t = parent;
2806    else {
2807      t = parent.predicate("fhir:"+name,index > -1);
2808    }
2809    composeDomainResource(t, "AllergyIntolerance", name, element, index);
2810    for (int i = 0; i < element.getIdentifier().size(); i++) {
2811      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
2812    }
2813    if (element.hasClinicalStatus()) {
2814      composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1);
2815    }
2816    if (element.hasVerificationStatus()) {
2817      composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1);
2818    }
2819    if (element.hasType()) {
2820      composeCodeableConcept(t, "AllergyIntolerance", "type", element.getType(), -1);
2821    }
2822    for (int i = 0; i < element.getCategory().size(); i++) {
2823      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
2824    }
2825    if (element.hasCriticalityElement()) {
2826      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
2827    }
2828    if (element.hasCode()) {
2829      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
2830    }
2831    if (element.hasPatient()) {
2832      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
2833    }
2834    if (element.hasEncounter()) {
2835      composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1);
2836    }
2837    if (element.hasOnset()) {
2838      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
2839    }
2840    if (element.hasRecordedDateElement()) {
2841      composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1);
2842    }
2843    for (int i = 0; i < element.getParticipant().size(); i++) {
2844      composeAllergyIntoleranceParticipantComponent(t, "AllergyIntolerance", "participant", element.getParticipant().get(i), i);
2845    }
2846    if (element.hasLastOccurrenceElement()) {
2847      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
2848    }
2849    for (int i = 0; i < element.getNote().size(); i++) {
2850      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
2851    }
2852    for (int i = 0; i < element.getReaction().size(); i++) {
2853      composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
2854    }
2855  }
2856
2857  protected void composeAllergyIntoleranceParticipantComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceParticipantComponent element, int index) {
2858    if (element == null) 
2859      return;
2860    Complex t;
2861    if (Utilities.noString(parentType))
2862      t = parent;
2863    else {
2864      t = parent.predicate("fhir:"+name,index > -1);
2865    }
2866    composeBackboneElement(t, "participant", name, element, index);
2867    if (element.hasFunction()) {
2868      composeCodeableConcept(t, "AllergyIntoleranceParticipantComponent", "function", element.getFunction(), -1);
2869    }
2870    if (element.hasActor()) {
2871      composeReference(t, "AllergyIntoleranceParticipantComponent", "actor", element.getActor(), -1);
2872    }
2873  }
2874
2875  protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
2876    if (element == null) 
2877      return;
2878    Complex t;
2879    if (Utilities.noString(parentType))
2880      t = parent;
2881    else {
2882      t = parent.predicate("fhir:"+name,index > -1);
2883    }
2884    composeBackboneElement(t, "reaction", name, element, index);
2885    if (element.hasSubstance()) {
2886      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1);
2887    }
2888    for (int i = 0; i < element.getManifestation().size(); i++) {
2889      composeCodeableReference(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i);
2890    }
2891    if (element.hasDescriptionElement()) {
2892      composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1);
2893    }
2894    if (element.hasOnsetElement()) {
2895      composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1);
2896    }
2897    if (element.hasSeverityElement()) {
2898      composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1);
2899    }
2900    if (element.hasExposureRoute()) {
2901      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1);
2902    }
2903    for (int i = 0; i < element.getNote().size(); i++) {
2904      composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i);
2905    }
2906  }
2907
2908  protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) {
2909    if (element == null) 
2910      return;
2911    Complex t;
2912    if (Utilities.noString(parentType))
2913      t = parent;
2914    else {
2915      t = parent.predicate("fhir:"+name,index > -1);
2916    }
2917    composeDomainResource(t, "Appointment", name, element, index);
2918    for (int i = 0; i < element.getIdentifier().size(); i++) {
2919      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
2920    }
2921    if (element.hasStatusElement()) {
2922      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
2923    }
2924    if (element.hasCancellationReason()) {
2925      composeCodeableConcept(t, "Appointment", "cancellationReason", element.getCancellationReason(), -1);
2926    }
2927    for (int i = 0; i < element.getClass_().size(); i++) {
2928      composeCodeableConcept(t, "Appointment", "class", element.getClass_().get(i), i);
2929    }
2930    for (int i = 0; i < element.getServiceCategory().size(); i++) {
2931      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i);
2932    }
2933    for (int i = 0; i < element.getServiceType().size(); i++) {
2934      composeCodeableReference(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
2935    }
2936    for (int i = 0; i < element.getSpecialty().size(); i++) {
2937      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
2938    }
2939    if (element.hasAppointmentType()) {
2940      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
2941    }
2942    for (int i = 0; i < element.getReason().size(); i++) {
2943      composeCodeableReference(t, "Appointment", "reason", element.getReason().get(i), i);
2944    }
2945    if (element.hasPriority()) {
2946      composeCodeableConcept(t, "Appointment", "priority", element.getPriority(), -1);
2947    }
2948    if (element.hasDescriptionElement()) {
2949      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
2950    }
2951    for (int i = 0; i < element.getReplaces().size(); i++) {
2952      composeReference(t, "Appointment", "replaces", element.getReplaces().get(i), i);
2953    }
2954    for (int i = 0; i < element.getVirtualService().size(); i++) {
2955      composeVirtualServiceDetail(t, "Appointment", "virtualService", element.getVirtualService().get(i), i);
2956    }
2957    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
2958      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
2959    }
2960    if (element.hasPreviousAppointment()) {
2961      composeReference(t, "Appointment", "previousAppointment", element.getPreviousAppointment(), -1);
2962    }
2963    if (element.hasOriginatingAppointment()) {
2964      composeReference(t, "Appointment", "originatingAppointment", element.getOriginatingAppointment(), -1);
2965    }
2966    if (element.hasStartElement()) {
2967      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
2968    }
2969    if (element.hasEndElement()) {
2970      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
2971    }
2972    if (element.hasMinutesDurationElement()) {
2973      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
2974    }
2975    for (int i = 0; i < element.getRequestedPeriod().size(); i++) {
2976      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
2977    }
2978    for (int i = 0; i < element.getSlot().size(); i++) {
2979      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
2980    }
2981    for (int i = 0; i < element.getAccount().size(); i++) {
2982      composeReference(t, "Appointment", "account", element.getAccount().get(i), i);
2983    }
2984    if (element.hasCreatedElement()) {
2985      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
2986    }
2987    if (element.hasCancellationDateElement()) {
2988      composeDateTime(t, "Appointment", "cancellationDate", element.getCancellationDateElement(), -1);
2989    }
2990    for (int i = 0; i < element.getNote().size(); i++) {
2991      composeAnnotation(t, "Appointment", "note", element.getNote().get(i), i);
2992    }
2993    for (int i = 0; i < element.getPatientInstruction().size(); i++) {
2994      composeCodeableReference(t, "Appointment", "patientInstruction", element.getPatientInstruction().get(i), i);
2995    }
2996    for (int i = 0; i < element.getBasedOn().size(); i++) {
2997      composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i);
2998    }
2999    if (element.hasSubject()) {
3000      composeReference(t, "Appointment", "subject", element.getSubject(), -1);
3001    }
3002    for (int i = 0; i < element.getParticipant().size(); i++) {
3003      composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
3004    }
3005    if (element.hasRecurrenceIdElement()) {
3006      composePositiveInt(t, "Appointment", "recurrenceId", element.getRecurrenceIdElement(), -1);
3007    }
3008    if (element.hasOccurrenceChangedElement()) {
3009      composeBoolean(t, "Appointment", "occurrenceChanged", element.getOccurrenceChangedElement(), -1);
3010    }
3011    for (int i = 0; i < element.getRecurrenceTemplate().size(); i++) {
3012      composeAppointmentRecurrenceTemplateComponent(t, "Appointment", "recurrenceTemplate", element.getRecurrenceTemplate().get(i), i);
3013    }
3014  }
3015
3016  protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
3017    if (element == null) 
3018      return;
3019    Complex t;
3020    if (Utilities.noString(parentType))
3021      t = parent;
3022    else {
3023      t = parent.predicate("fhir:"+name,index > -1);
3024    }
3025    composeBackboneElement(t, "participant", name, element, index);
3026    for (int i = 0; i < element.getType().size(); i++) {
3027      composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i);
3028    }
3029    if (element.hasPeriod()) {
3030      composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1);
3031    }
3032    if (element.hasActor()) {
3033      composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1);
3034    }
3035    if (element.hasRequiredElement()) {
3036      composeBoolean(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1);
3037    }
3038    if (element.hasStatusElement()) {
3039      composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1);
3040    }
3041  }
3042
3043  protected void composeAppointmentRecurrenceTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateComponent element, int index) {
3044    if (element == null) 
3045      return;
3046    Complex t;
3047    if (Utilities.noString(parentType))
3048      t = parent;
3049    else {
3050      t = parent.predicate("fhir:"+name,index > -1);
3051    }
3052    composeBackboneElement(t, "recurrenceTemplate", name, element, index);
3053    if (element.hasTimezone()) {
3054      composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "timezone", element.getTimezone(), -1);
3055    }
3056    if (element.hasRecurrenceType()) {
3057      composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "recurrenceType", element.getRecurrenceType(), -1);
3058    }
3059    if (element.hasLastOccurrenceDateElement()) {
3060      composeDate(t, "AppointmentRecurrenceTemplateComponent", "lastOccurrenceDate", element.getLastOccurrenceDateElement(), -1);
3061    }
3062    if (element.hasOccurrenceCountElement()) {
3063      composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "occurrenceCount", element.getOccurrenceCountElement(), -1);
3064    }
3065    for (int i = 0; i < element.getOccurrenceDate().size(); i++) {
3066      composeDate(t, "AppointmentRecurrenceTemplateComponent", "occurrenceDate", element.getOccurrenceDate().get(i), i);
3067    }
3068    if (element.hasWeeklyTemplate()) {
3069      composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "weeklyTemplate", element.getWeeklyTemplate(), -1);
3070    }
3071    if (element.hasMonthlyTemplate()) {
3072      composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "monthlyTemplate", element.getMonthlyTemplate(), -1);
3073    }
3074    if (element.hasYearlyTemplate()) {
3075      composeAppointmentRecurrenceTemplateYearlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "yearlyTemplate", element.getYearlyTemplate(), -1);
3076    }
3077    for (int i = 0; i < element.getExcludingDate().size(); i++) {
3078      composeDate(t, "AppointmentRecurrenceTemplateComponent", "excludingDate", element.getExcludingDate().get(i), i);
3079    }
3080    for (int i = 0; i < element.getExcludingRecurrenceId().size(); i++) {
3081      composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "excludingRecurrenceId", element.getExcludingRecurrenceId().get(i), i);
3082    }
3083  }
3084
3085  protected void composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent element, int index) {
3086    if (element == null) 
3087      return;
3088    Complex t;
3089    if (Utilities.noString(parentType))
3090      t = parent;
3091    else {
3092      t = parent.predicate("fhir:"+name,index > -1);
3093    }
3094    composeBackboneElement(t, "weeklyTemplate", name, element, index);
3095    if (element.hasMondayElement()) {
3096      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "monday", element.getMondayElement(), -1);
3097    }
3098    if (element.hasTuesdayElement()) {
3099      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "tuesday", element.getTuesdayElement(), -1);
3100    }
3101    if (element.hasWednesdayElement()) {
3102      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "wednesday", element.getWednesdayElement(), -1);
3103    }
3104    if (element.hasThursdayElement()) {
3105      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "thursday", element.getThursdayElement(), -1);
3106    }
3107    if (element.hasFridayElement()) {
3108      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "friday", element.getFridayElement(), -1);
3109    }
3110    if (element.hasSaturdayElement()) {
3111      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "saturday", element.getSaturdayElement(), -1);
3112    }
3113    if (element.hasSundayElement()) {
3114      composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "sunday", element.getSundayElement(), -1);
3115    }
3116    if (element.hasWeekIntervalElement()) {
3117      composePositiveInt(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "weekInterval", element.getWeekIntervalElement(), -1);
3118    }
3119  }
3120
3121  protected void composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent element, int index) {
3122    if (element == null) 
3123      return;
3124    Complex t;
3125    if (Utilities.noString(parentType))
3126      t = parent;
3127    else {
3128      t = parent.predicate("fhir:"+name,index > -1);
3129    }
3130    composeBackboneElement(t, "monthlyTemplate", name, element, index);
3131    if (element.hasDayOfMonthElement()) {
3132      composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfMonth", element.getDayOfMonthElement(), -1);
3133    }
3134    if (element.hasNthWeekOfMonth()) {
3135      composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "nthWeekOfMonth", element.getNthWeekOfMonth(), -1);
3136    }
3137    if (element.hasDayOfWeek()) {
3138      composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfWeek", element.getDayOfWeek(), -1);
3139    }
3140    if (element.hasMonthIntervalElement()) {
3141      composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "monthInterval", element.getMonthIntervalElement(), -1);
3142    }
3143  }
3144
3145  protected void composeAppointmentRecurrenceTemplateYearlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent element, int index) {
3146    if (element == null) 
3147      return;
3148    Complex t;
3149    if (Utilities.noString(parentType))
3150      t = parent;
3151    else {
3152      t = parent.predicate("fhir:"+name,index > -1);
3153    }
3154    composeBackboneElement(t, "yearlyTemplate", name, element, index);
3155    if (element.hasYearIntervalElement()) {
3156      composePositiveInt(t, "AppointmentRecurrenceTemplateYearlyTemplateComponent", "yearInterval", element.getYearIntervalElement(), -1);
3157    }
3158  }
3159
3160  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
3161    if (element == null) 
3162      return;
3163    Complex t;
3164    if (Utilities.noString(parentType))
3165      t = parent;
3166    else {
3167      t = parent.predicate("fhir:"+name,index > -1);
3168    }
3169    composeDomainResource(t, "AppointmentResponse", name, element, index);
3170    for (int i = 0; i < element.getIdentifier().size(); i++) {
3171      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
3172    }
3173    if (element.hasAppointment()) {
3174      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
3175    }
3176    if (element.hasProposedNewTimeElement()) {
3177      composeBoolean(t, "AppointmentResponse", "proposedNewTime", element.getProposedNewTimeElement(), -1);
3178    }
3179    if (element.hasStartElement()) {
3180      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
3181    }
3182    if (element.hasEndElement()) {
3183      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
3184    }
3185    for (int i = 0; i < element.getParticipantType().size(); i++) {
3186      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
3187    }
3188    if (element.hasActor()) {
3189      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
3190    }
3191    if (element.hasParticipantStatusElement()) {
3192      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
3193    }
3194    if (element.hasCommentElement()) {
3195      composeMarkdown(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
3196    }
3197    if (element.hasRecurringElement()) {
3198      composeBoolean(t, "AppointmentResponse", "recurring", element.getRecurringElement(), -1);
3199    }
3200    if (element.hasOccurrenceDateElement()) {
3201      composeDate(t, "AppointmentResponse", "occurrenceDate", element.getOccurrenceDateElement(), -1);
3202    }
3203    if (element.hasRecurrenceIdElement()) {
3204      composePositiveInt(t, "AppointmentResponse", "recurrenceId", element.getRecurrenceIdElement(), -1);
3205    }
3206  }
3207
3208  protected void composeArtifactAssessment(Complex parent, String parentType, String name, ArtifactAssessment element, int index) {
3209    if (element == null) 
3210      return;
3211    Complex t;
3212    if (Utilities.noString(parentType))
3213      t = parent;
3214    else {
3215      t = parent.predicate("fhir:"+name,index > -1);
3216    }
3217    composeDomainResource(t, "ArtifactAssessment", name, element, index);
3218    for (int i = 0; i < element.getIdentifier().size(); i++) {
3219      composeIdentifier(t, "ArtifactAssessment", "identifier", element.getIdentifier().get(i), i);
3220    }
3221    if (element.hasTitleElement()) {
3222      composeString(t, "ArtifactAssessment", "title", element.getTitleElement(), -1);
3223    }
3224    if (element.hasCiteAs()) {
3225      composeType(t, "ArtifactAssessment", "citeAs", element.getCiteAs(), -1);
3226    }
3227    if (element.hasDateElement()) {
3228      composeDateTime(t, "ArtifactAssessment", "date", element.getDateElement(), -1);
3229    }
3230    if (element.hasCopyrightElement()) {
3231      composeMarkdown(t, "ArtifactAssessment", "copyright", element.getCopyrightElement(), -1);
3232    }
3233    if (element.hasApprovalDateElement()) {
3234      composeDate(t, "ArtifactAssessment", "approvalDate", element.getApprovalDateElement(), -1);
3235    }
3236    if (element.hasLastReviewDateElement()) {
3237      composeDate(t, "ArtifactAssessment", "lastReviewDate", element.getLastReviewDateElement(), -1);
3238    }
3239    if (element.hasArtifact()) {
3240      composeType(t, "ArtifactAssessment", "artifact", element.getArtifact(), -1);
3241    }
3242    for (int i = 0; i < element.getContent().size(); i++) {
3243      composeArtifactAssessmentContentComponent(t, "ArtifactAssessment", "content", element.getContent().get(i), i);
3244    }
3245    if (element.hasWorkflowStatusElement()) {
3246      composeEnum(t, "ArtifactAssessment", "workflowStatus", element.getWorkflowStatusElement(), -1);
3247    }
3248    if (element.hasDispositionElement()) {
3249      composeEnum(t, "ArtifactAssessment", "disposition", element.getDispositionElement(), -1);
3250    }
3251  }
3252
3253  protected void composeArtifactAssessmentContentComponent(Complex parent, String parentType, String name, ArtifactAssessment.ArtifactAssessmentContentComponent element, int index) {
3254    if (element == null) 
3255      return;
3256    Complex t;
3257    if (Utilities.noString(parentType))
3258      t = parent;
3259    else {
3260      t = parent.predicate("fhir:"+name,index > -1);
3261    }
3262    composeBackboneElement(t, "content", name, element, index);
3263    if (element.hasInformationTypeElement()) {
3264      composeEnum(t, "ArtifactAssessmentContentComponent", "informationType", element.getInformationTypeElement(), -1);
3265    }
3266    if (element.hasSummaryElement()) {
3267      composeMarkdown(t, "ArtifactAssessmentContentComponent", "summary", element.getSummaryElement(), -1);
3268    }
3269    if (element.hasType()) {
3270      composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "type", element.getType(), -1);
3271    }
3272    for (int i = 0; i < element.getClassifier().size(); i++) {
3273      composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "classifier", element.getClassifier().get(i), i);
3274    }
3275    if (element.hasQuantity()) {
3276      composeQuantity(t, "ArtifactAssessmentContentComponent", "quantity", element.getQuantity(), -1);
3277    }
3278    if (element.hasAuthor()) {
3279      composeReference(t, "ArtifactAssessmentContentComponent", "author", element.getAuthor(), -1);
3280    }
3281    for (int i = 0; i < element.getPath().size(); i++) {
3282      composeUri(t, "ArtifactAssessmentContentComponent", "path", element.getPath().get(i), i);
3283    }
3284    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
3285      composeRelatedArtifact(t, "ArtifactAssessmentContentComponent", "relatedArtifact", element.getRelatedArtifact().get(i), i);
3286    }
3287    if (element.hasFreeToShareElement()) {
3288      composeBoolean(t, "ArtifactAssessmentContentComponent", "freeToShare", element.getFreeToShareElement(), -1);
3289    }
3290    for (int i = 0; i < element.getComponent().size(); i++) {
3291      composeArtifactAssessmentContentComponent(t, "ArtifactAssessmentContentComponent", "component", element.getComponent().get(i), i);
3292    }
3293  }
3294
3295  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) {
3296    if (element == null) 
3297      return;
3298    Complex t;
3299    if (Utilities.noString(parentType))
3300      t = parent;
3301    else {
3302      t = parent.predicate("fhir:"+name,index > -1);
3303    }
3304    composeDomainResource(t, "AuditEvent", name, element, index);
3305    for (int i = 0; i < element.getCategory().size(); i++) {
3306      composeCodeableConcept(t, "AuditEvent", "category", element.getCategory().get(i), i);
3307    }
3308    if (element.hasCode()) {
3309      composeCodeableConcept(t, "AuditEvent", "code", element.getCode(), -1);
3310    }
3311    if (element.hasActionElement()) {
3312      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
3313    }
3314    if (element.hasSeverityElement()) {
3315      composeEnum(t, "AuditEvent", "severity", element.getSeverityElement(), -1);
3316    }
3317    if (element.hasOccurred()) {
3318      composeType(t, "AuditEvent", "occurred", element.getOccurred(), -1);
3319    }
3320    if (element.hasRecordedElement()) {
3321      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
3322    }
3323    if (element.hasOutcome()) {
3324      composeAuditEventOutcomeComponent(t, "AuditEvent", "outcome", element.getOutcome(), -1);
3325    }
3326    for (int i = 0; i < element.getAuthorization().size(); i++) {
3327      composeCodeableConcept(t, "AuditEvent", "authorization", element.getAuthorization().get(i), i);
3328    }
3329    for (int i = 0; i < element.getBasedOn().size(); i++) {
3330      composeReference(t, "AuditEvent", "basedOn", element.getBasedOn().get(i), i);
3331    }
3332    if (element.hasPatient()) {
3333      composeReference(t, "AuditEvent", "patient", element.getPatient(), -1);
3334    }
3335    if (element.hasEncounter()) {
3336      composeReference(t, "AuditEvent", "encounter", element.getEncounter(), -1);
3337    }
3338    for (int i = 0; i < element.getAgent().size(); i++) {
3339      composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
3340    }
3341    if (element.hasSource()) {
3342      composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
3343    }
3344    for (int i = 0; i < element.getEntity().size(); i++) {
3345      composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
3346    }
3347  }
3348
3349  protected void composeAuditEventOutcomeComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventOutcomeComponent element, int index) {
3350    if (element == null) 
3351      return;
3352    Complex t;
3353    if (Utilities.noString(parentType))
3354      t = parent;
3355    else {
3356      t = parent.predicate("fhir:"+name,index > -1);
3357    }
3358    composeBackboneElement(t, "outcome", name, element, index);
3359    if (element.hasCode()) {
3360      composeCoding(t, "AuditEventOutcomeComponent", "code", element.getCode(), -1);
3361    }
3362    for (int i = 0; i < element.getDetail().size(); i++) {
3363      composeCodeableConcept(t, "AuditEventOutcomeComponent", "detail", element.getDetail().get(i), i);
3364    }
3365  }
3366
3367  protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
3368    if (element == null) 
3369      return;
3370    Complex t;
3371    if (Utilities.noString(parentType))
3372      t = parent;
3373    else {
3374      t = parent.predicate("fhir:"+name,index > -1);
3375    }
3376    composeBackboneElement(t, "agent", name, element, index);
3377    if (element.hasType()) {
3378      composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1);
3379    }
3380    for (int i = 0; i < element.getRole().size(); i++) {
3381      composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i);
3382    }
3383    if (element.hasWho()) {
3384      composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1);
3385    }
3386    if (element.hasRequestorElement()) {
3387      composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1);
3388    }
3389    if (element.hasLocation()) {
3390      composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1);
3391    }
3392    for (int i = 0; i < element.getPolicy().size(); i++) {
3393      composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i);
3394    }
3395    if (element.hasNetwork()) {
3396      composeType(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1);
3397    }
3398    for (int i = 0; i < element.getAuthorization().size(); i++) {
3399      composeCodeableConcept(t, "AuditEventAgentComponent", "authorization", element.getAuthorization().get(i), i);
3400    }
3401  }
3402
3403  protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
3404    if (element == null) 
3405      return;
3406    Complex t;
3407    if (Utilities.noString(parentType))
3408      t = parent;
3409    else {
3410      t = parent.predicate("fhir:"+name,index > -1);
3411    }
3412    composeBackboneElement(t, "source", name, element, index);
3413    if (element.hasSite()) {
3414      composeReference(t, "AuditEventSourceComponent", "site", element.getSite(), -1);
3415    }
3416    if (element.hasObserver()) {
3417      composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1);
3418    }
3419    for (int i = 0; i < element.getType().size(); i++) {
3420      composeCodeableConcept(t, "AuditEventSourceComponent", "type", element.getType().get(i), i);
3421    }
3422  }
3423
3424  protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
3425    if (element == null) 
3426      return;
3427    Complex t;
3428    if (Utilities.noString(parentType))
3429      t = parent;
3430    else {
3431      t = parent.predicate("fhir:"+name,index > -1);
3432    }
3433    composeBackboneElement(t, "entity", name, element, index);
3434    if (element.hasWhat()) {
3435      composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1);
3436    }
3437    if (element.hasRole()) {
3438      composeCodeableConcept(t, "AuditEventEntityComponent", "role", element.getRole(), -1);
3439    }
3440    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
3441      composeCodeableConcept(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i);
3442    }
3443    if (element.hasQueryElement()) {
3444      composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1);
3445    }
3446    for (int i = 0; i < element.getDetail().size(); i++) {
3447      composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i);
3448    }
3449    for (int i = 0; i < element.getAgent().size(); i++) {
3450      composeAuditEventAgentComponent(t, "AuditEventEntityComponent", "agent", element.getAgent().get(i), i);
3451    }
3452  }
3453
3454  protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
3455    if (element == null) 
3456      return;
3457    Complex t;
3458    if (Utilities.noString(parentType))
3459      t = parent;
3460    else {
3461      t = parent.predicate("fhir:"+name,index > -1);
3462    }
3463    composeBackboneElement(t, "detail", name, element, index);
3464    if (element.hasType()) {
3465      composeCodeableConcept(t, "AuditEventEntityDetailComponent", "type", element.getType(), -1);
3466    }
3467    if (element.hasValue()) {
3468      composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1);
3469    }
3470  }
3471
3472  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
3473    if (element == null) 
3474      return;
3475    Complex t;
3476    if (Utilities.noString(parentType))
3477      t = parent;
3478    else {
3479      t = parent.predicate("fhir:"+name,index > -1);
3480    }
3481    composeDomainResource(t, "Basic", name, element, index);
3482    for (int i = 0; i < element.getIdentifier().size(); i++) {
3483      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
3484    }
3485    if (element.hasCode()) {
3486      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
3487    }
3488    if (element.hasSubject()) {
3489      composeReference(t, "Basic", "subject", element.getSubject(), -1);
3490    }
3491    if (element.hasCreatedElement()) {
3492      composeDateTime(t, "Basic", "created", element.getCreatedElement(), -1);
3493    }
3494    if (element.hasAuthor()) {
3495      composeReference(t, "Basic", "author", element.getAuthor(), -1);
3496    }
3497  }
3498
3499  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
3500    if (element == null) 
3501      return;
3502    Complex t;
3503    if (Utilities.noString(parentType))
3504      t = parent;
3505    else {
3506      t = parent.predicate("fhir:"+name,index > -1);
3507    }
3508    composeResource(t, "Binary", name, element, index);
3509    if (element.hasContentTypeElement()) {
3510      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
3511    }
3512    if (element.hasSecurityContext()) {
3513      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
3514    }
3515    if (element.hasDataElement()) {
3516      composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1);
3517    }
3518  }
3519
3520  protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) {
3521    if (element == null) 
3522      return;
3523    Complex t;
3524    if (Utilities.noString(parentType))
3525      t = parent;
3526    else {
3527      t = parent.predicate("fhir:"+name,index > -1);
3528    }
3529    composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index);
3530    if (element.hasProductCategory()) {
3531      composeCoding(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategory(), -1);
3532    }
3533    if (element.hasProductCode()) {
3534      composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1);
3535    }
3536    for (int i = 0; i < element.getParent().size(); i++) {
3537      composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i);
3538    }
3539    for (int i = 0; i < element.getRequest().size(); i++) {
3540      composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i);
3541    }
3542    for (int i = 0; i < element.getIdentifier().size(); i++) {
3543      composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i);
3544    }
3545    if (element.hasBiologicalSourceEvent()) {
3546      composeIdentifier(t, "BiologicallyDerivedProduct", "biologicalSourceEvent", element.getBiologicalSourceEvent(), -1);
3547    }
3548    for (int i = 0; i < element.getProcessingFacility().size(); i++) {
3549      composeReference(t, "BiologicallyDerivedProduct", "processingFacility", element.getProcessingFacility().get(i), i);
3550    }
3551    if (element.hasDivisionElement()) {
3552      composeString(t, "BiologicallyDerivedProduct", "division", element.getDivisionElement(), -1);
3553    }
3554    if (element.hasProductStatus()) {
3555      composeCoding(t, "BiologicallyDerivedProduct", "productStatus", element.getProductStatus(), -1);
3556    }
3557    if (element.hasExpirationDateElement()) {
3558      composeDateTime(t, "BiologicallyDerivedProduct", "expirationDate", element.getExpirationDateElement(), -1);
3559    }
3560    if (element.hasCollection()) {
3561      composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1);
3562    }
3563    if (element.hasStorageTempRequirements()) {
3564      composeRange(t, "BiologicallyDerivedProduct", "storageTempRequirements", element.getStorageTempRequirements(), -1);
3565    }
3566    for (int i = 0; i < element.getProperty().size(); i++) {
3567      composeBiologicallyDerivedProductPropertyComponent(t, "BiologicallyDerivedProduct", "property", element.getProperty().get(i), i);
3568    }
3569  }
3570
3571  protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) {
3572    if (element == null) 
3573      return;
3574    Complex t;
3575    if (Utilities.noString(parentType))
3576      t = parent;
3577    else {
3578      t = parent.predicate("fhir:"+name,index > -1);
3579    }
3580    composeBackboneElement(t, "collection", name, element, index);
3581    if (element.hasCollector()) {
3582      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1);
3583    }
3584    if (element.hasSource()) {
3585      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1);
3586    }
3587    if (element.hasCollected()) {
3588      composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1);
3589    }
3590  }
3591
3592  protected void composeBiologicallyDerivedProductPropertyComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent element, int index) {
3593    if (element == null) 
3594      return;
3595    Complex t;
3596    if (Utilities.noString(parentType))
3597      t = parent;
3598    else {
3599      t = parent.predicate("fhir:"+name,index > -1);
3600    }
3601    composeBackboneElement(t, "property", name, element, index);
3602    if (element.hasType()) {
3603      composeCodeableConcept(t, "BiologicallyDerivedProductPropertyComponent", "type", element.getType(), -1);
3604    }
3605    if (element.hasValue()) {
3606      composeType(t, "BiologicallyDerivedProductPropertyComponent", "value", element.getValue(), -1);
3607    }
3608  }
3609
3610  protected void composeBiologicallyDerivedProductDispense(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense element, int index) {
3611    if (element == null) 
3612      return;
3613    Complex t;
3614    if (Utilities.noString(parentType))
3615      t = parent;
3616    else {
3617      t = parent.predicate("fhir:"+name,index > -1);
3618    }
3619    composeDomainResource(t, "BiologicallyDerivedProductDispense", name, element, index);
3620    for (int i = 0; i < element.getIdentifier().size(); i++) {
3621      composeIdentifier(t, "BiologicallyDerivedProductDispense", "identifier", element.getIdentifier().get(i), i);
3622    }
3623    for (int i = 0; i < element.getBasedOn().size(); i++) {
3624      composeReference(t, "BiologicallyDerivedProductDispense", "basedOn", element.getBasedOn().get(i), i);
3625    }
3626    for (int i = 0; i < element.getPartOf().size(); i++) {
3627      composeReference(t, "BiologicallyDerivedProductDispense", "partOf", element.getPartOf().get(i), i);
3628    }
3629    if (element.hasStatusElement()) {
3630      composeEnum(t, "BiologicallyDerivedProductDispense", "status", element.getStatusElement(), -1);
3631    }
3632    if (element.hasOriginRelationshipType()) {
3633      composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "originRelationshipType", element.getOriginRelationshipType(), -1);
3634    }
3635    if (element.hasProduct()) {
3636      composeReference(t, "BiologicallyDerivedProductDispense", "product", element.getProduct(), -1);
3637    }
3638    if (element.hasPatient()) {
3639      composeReference(t, "BiologicallyDerivedProductDispense", "patient", element.getPatient(), -1);
3640    }
3641    if (element.hasMatchStatus()) {
3642      composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "matchStatus", element.getMatchStatus(), -1);
3643    }
3644    for (int i = 0; i < element.getPerformer().size(); i++) {
3645      composeBiologicallyDerivedProductDispensePerformerComponent(t, "BiologicallyDerivedProductDispense", "performer", element.getPerformer().get(i), i);
3646    }
3647    if (element.hasLocation()) {
3648      composeReference(t, "BiologicallyDerivedProductDispense", "location", element.getLocation(), -1);
3649    }
3650    if (element.hasQuantity()) {
3651      composeQuantity(t, "BiologicallyDerivedProductDispense", "quantity", element.getQuantity(), -1);
3652    }
3653    if (element.hasPreparedDateElement()) {
3654      composeDateTime(t, "BiologicallyDerivedProductDispense", "preparedDate", element.getPreparedDateElement(), -1);
3655    }
3656    if (element.hasWhenHandedOverElement()) {
3657      composeDateTime(t, "BiologicallyDerivedProductDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
3658    }
3659    if (element.hasDestination()) {
3660      composeReference(t, "BiologicallyDerivedProductDispense", "destination", element.getDestination(), -1);
3661    }
3662    for (int i = 0; i < element.getNote().size(); i++) {
3663      composeAnnotation(t, "BiologicallyDerivedProductDispense", "note", element.getNote().get(i), i);
3664    }
3665    if (element.hasUsageInstructionElement()) {
3666      composeString(t, "BiologicallyDerivedProductDispense", "usageInstruction", element.getUsageInstructionElement(), -1);
3667    }
3668  }
3669
3670  protected void composeBiologicallyDerivedProductDispensePerformerComponent(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense.BiologicallyDerivedProductDispensePerformerComponent element, int index) {
3671    if (element == null) 
3672      return;
3673    Complex t;
3674    if (Utilities.noString(parentType))
3675      t = parent;
3676    else {
3677      t = parent.predicate("fhir:"+name,index > -1);
3678    }
3679    composeBackboneElement(t, "performer", name, element, index);
3680    if (element.hasFunction()) {
3681      composeCodeableConcept(t, "BiologicallyDerivedProductDispensePerformerComponent", "function", element.getFunction(), -1);
3682    }
3683    if (element.hasActor()) {
3684      composeReference(t, "BiologicallyDerivedProductDispensePerformerComponent", "actor", element.getActor(), -1);
3685    }
3686  }
3687
3688  protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) {
3689    if (element == null) 
3690      return;
3691    Complex t;
3692    if (Utilities.noString(parentType))
3693      t = parent;
3694    else {
3695      t = parent.predicate("fhir:"+name,index > -1);
3696    }
3697    composeDomainResource(t, "BodyStructure", name, element, index);
3698    for (int i = 0; i < element.getIdentifier().size(); i++) {
3699      composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i);
3700    }
3701    if (element.hasActiveElement()) {
3702      composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1);
3703    }
3704    if (element.hasMorphology()) {
3705      composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1);
3706    }
3707    for (int i = 0; i < element.getIncludedStructure().size(); i++) {
3708      composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "includedStructure", element.getIncludedStructure().get(i), i);
3709    }
3710    for (int i = 0; i < element.getExcludedStructure().size(); i++) {
3711      composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "excludedStructure", element.getExcludedStructure().get(i), i);
3712    }
3713    if (element.hasDescriptionElement()) {
3714      composeMarkdown(t, "BodyStructure", "description", element.getDescriptionElement(), -1);
3715    }
3716    for (int i = 0; i < element.getImage().size(); i++) {
3717      composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i);
3718    }
3719    if (element.hasPatient()) {
3720      composeReference(t, "BodyStructure", "patient", element.getPatient(), -1);
3721    }
3722  }
3723
3724  protected void composeBodyStructureIncludedStructureComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureComponent element, int index) {
3725    if (element == null) 
3726      return;
3727    Complex t;
3728    if (Utilities.noString(parentType))
3729      t = parent;
3730    else {
3731      t = parent.predicate("fhir:"+name,index > -1);
3732    }
3733    composeBackboneElement(t, "includedStructure", name, element, index);
3734    if (element.hasStructure()) {
3735      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "structure", element.getStructure(), -1);
3736    }
3737    if (element.hasLaterality()) {
3738      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "laterality", element.getLaterality(), -1);
3739    }
3740    for (int i = 0; i < element.getBodyLandmarkOrientation().size(); i++) {
3741      composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(t, "BodyStructureIncludedStructureComponent", "bodyLandmarkOrientation", element.getBodyLandmarkOrientation().get(i), i);
3742    }
3743    for (int i = 0; i < element.getSpatialReference().size(); i++) {
3744      composeReference(t, "BodyStructureIncludedStructureComponent", "spatialReference", element.getSpatialReference().get(i), i);
3745    }
3746    for (int i = 0; i < element.getQualifier().size(); i++) {
3747      composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "qualifier", element.getQualifier().get(i), i);
3748    }
3749  }
3750
3751  protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationComponent element, int index) {
3752    if (element == null) 
3753      return;
3754    Complex t;
3755    if (Utilities.noString(parentType))
3756      t = parent;
3757    else {
3758      t = parent.predicate("fhir:"+name,index > -1);
3759    }
3760    composeBackboneElement(t, "bodyLandmarkOrientation", name, element, index);
3761    for (int i = 0; i < element.getLandmarkDescription().size(); i++) {
3762      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "landmarkDescription", element.getLandmarkDescription().get(i), i);
3763    }
3764    for (int i = 0; i < element.getClockFacePosition().size(); i++) {
3765      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "clockFacePosition", element.getClockFacePosition().get(i), i);
3766    }
3767    for (int i = 0; i < element.getDistanceFromLandmark().size(); i++) {
3768      composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "distanceFromLandmark", element.getDistanceFromLandmark().get(i), i);
3769    }
3770    for (int i = 0; i < element.getSurfaceOrientation().size(); i++) {
3771      composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "surfaceOrientation", element.getSurfaceOrientation().get(i), i);
3772    }
3773  }
3774
3775  protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent element, int index) {
3776    if (element == null) 
3777      return;
3778    Complex t;
3779    if (Utilities.noString(parentType))
3780      t = parent;
3781    else {
3782      t = parent.predicate("fhir:"+name,index > -1);
3783    }
3784    composeBackboneElement(t, "distanceFromLandmark", name, element, index);
3785    for (int i = 0; i < element.getDevice().size(); i++) {
3786      composeCodeableReference(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "device", element.getDevice().get(i), i);
3787    }
3788    for (int i = 0; i < element.getValue().size(); i++) {
3789      composeQuantity(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "value", element.getValue().get(i), i);
3790    }
3791  }
3792
3793  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
3794    if (element == null) 
3795      return;
3796    Complex t;
3797    if (Utilities.noString(parentType))
3798      t = parent;
3799    else {
3800      t = parent.predicate("fhir:"+name,index > -1);
3801    }
3802    composeResource(t, "Bundle", name, element, index);
3803    if (element.hasIdentifier()) {
3804      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
3805    }
3806    if (element.hasTypeElement()) {
3807      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
3808    }
3809    if (element.hasTimestampElement()) {
3810      composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1);
3811    }
3812    if (element.hasTotalElement()) {
3813      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
3814    }
3815    for (int i = 0; i < element.getLink().size(); i++) {
3816      composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
3817    }
3818    for (int i = 0; i < element.getEntry().size(); i++) {
3819      composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
3820    }
3821    if (element.hasSignature()) {
3822      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
3823    }
3824    if (element.hasIssues()) {
3825      composeResource(t, "Bundle", "issues", element.getIssues(), -1);
3826    }
3827  }
3828
3829  protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) {
3830    if (element == null) 
3831      return;
3832    Complex t;
3833    if (Utilities.noString(parentType))
3834      t = parent;
3835    else {
3836      t = parent.predicate("fhir:"+name,index > -1);
3837    }
3838    composeBackboneElement(t, "link", name, element, index);
3839    if (element.hasRelationElement()) {
3840      composeEnum(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1);
3841    }
3842    if (element.hasUrlElement()) {
3843      composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1);
3844    }
3845  }
3846
3847  protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) {
3848    if (element == null) 
3849      return;
3850    Complex t;
3851    if (Utilities.noString(parentType))
3852      t = parent;
3853    else {
3854      t = parent.predicate("fhir:"+name,index > -1);
3855    }
3856    composeBackboneElement(t, "entry", name, element, index);
3857    for (int i = 0; i < element.getLink().size(); i++) {
3858      composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i);
3859    }
3860    if (element.hasFullUrlElement()) {
3861      composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1);
3862    }
3863    if (element.hasResource()) {
3864      composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1);
3865    }
3866    if (element.hasSearch()) {
3867      composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1);
3868    }
3869    if (element.hasRequest()) {
3870      composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1);
3871    }
3872    if (element.hasResponse()) {
3873      composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1);
3874    }
3875  }
3876
3877  protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
3878    if (element == null) 
3879      return;
3880    Complex t;
3881    if (Utilities.noString(parentType))
3882      t = parent;
3883    else {
3884      t = parent.predicate("fhir:"+name,index > -1);
3885    }
3886    composeBackboneElement(t, "search", name, element, index);
3887    if (element.hasModeElement()) {
3888      composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1);
3889    }
3890    if (element.hasScoreElement()) {
3891      composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1);
3892    }
3893  }
3894
3895  protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
3896    if (element == null) 
3897      return;
3898    Complex t;
3899    if (Utilities.noString(parentType))
3900      t = parent;
3901    else {
3902      t = parent.predicate("fhir:"+name,index > -1);
3903    }
3904    composeBackboneElement(t, "request", name, element, index);
3905    if (element.hasMethodElement()) {
3906      composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1);
3907    }
3908    if (element.hasUrlElement()) {
3909      composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1);
3910    }
3911    if (element.hasIfNoneMatchElement()) {
3912      composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
3913    }
3914    if (element.hasIfModifiedSinceElement()) {
3915      composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
3916    }
3917    if (element.hasIfMatchElement()) {
3918      composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1);
3919    }
3920    if (element.hasIfNoneExistElement()) {
3921      composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1);
3922    }
3923  }
3924
3925  protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
3926    if (element == null) 
3927      return;
3928    Complex t;
3929    if (Utilities.noString(parentType))
3930      t = parent;
3931    else {
3932      t = parent.predicate("fhir:"+name,index > -1);
3933    }
3934    composeBackboneElement(t, "response", name, element, index);
3935    if (element.hasStatusElement()) {
3936      composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1);
3937    }
3938    if (element.hasLocationElement()) {
3939      composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1);
3940    }
3941    if (element.hasEtagElement()) {
3942      composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1);
3943    }
3944    if (element.hasLastModifiedElement()) {
3945      composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1);
3946    }
3947    if (element.hasOutcome()) {
3948      composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1);
3949    }
3950  }
3951
3952  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) {
3953    if (element == null) 
3954      return;
3955    Complex t;
3956    if (Utilities.noString(parentType))
3957      t = parent;
3958    else {
3959      t = parent.predicate("fhir:"+name,index > -1);
3960    }
3961    composeCanonicalResource(t, "CapabilityStatement", name, element, index);
3962    if (element.hasUrlElement()) {
3963      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
3964    }
3965    for (int i = 0; i < element.getIdentifier().size(); i++) {
3966      composeIdentifier(t, "CapabilityStatement", "identifier", element.getIdentifier().get(i), i);
3967    }
3968    if (element.hasVersionElement()) {
3969      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
3970    }
3971    if (element.hasVersionAlgorithm()) {
3972      composeType(t, "CapabilityStatement", "versionAlgorithm", element.getVersionAlgorithm(), -1);
3973    }
3974    if (element.hasNameElement()) {
3975      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
3976    }
3977    if (element.hasTitleElement()) {
3978      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
3979    }
3980    if (element.hasStatusElement()) {
3981      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
3982    }
3983    if (element.hasExperimentalElement()) {
3984      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
3985    }
3986    if (element.hasDateElement()) {
3987      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
3988    }
3989    if (element.hasPublisherElement()) {
3990      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
3991    }
3992    for (int i = 0; i < element.getContact().size(); i++) {
3993      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
3994    }
3995    if (element.hasDescriptionElement()) {
3996      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
3997    }
3998    for (int i = 0; i < element.getUseContext().size(); i++) {
3999      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
4000    }
4001    for (int i = 0; i < element.getJurisdiction().size(); i++) {
4002      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
4003    }
4004    if (element.hasPurposeElement()) {
4005      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
4006    }
4007    if (element.hasCopyrightElement()) {
4008      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
4009    }
4010    if (element.hasCopyrightLabelElement()) {
4011      composeString(t, "CapabilityStatement", "copyrightLabel", element.getCopyrightLabelElement(), -1);
4012    }
4013    if (element.hasKindElement()) {
4014      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
4015    }
4016    for (int i = 0; i < element.getInstantiates().size(); i++) {
4017      composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
4018    }
4019    for (int i = 0; i < element.getImports().size(); i++) {
4020      composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i);
4021    }
4022    if (element.hasSoftware()) {
4023      composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
4024    }
4025    if (element.hasImplementation()) {
4026      composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
4027    }
4028    if (element.hasFhirVersionElement()) {
4029      composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
4030    }
4031    for (int i = 0; i < element.getFormat().size(); i++) {
4032      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
4033    }
4034    for (int i = 0; i < element.getPatchFormat().size(); i++) {
4035      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
4036    }
4037    for (int i = 0; i < element.getAcceptLanguage().size(); i++) {
4038      composeCode(t, "CapabilityStatement", "acceptLanguage", element.getAcceptLanguage().get(i), i);
4039    }
4040    for (int i = 0; i < element.getImplementationGuide().size(); i++) {
4041      composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
4042    }
4043    for (int i = 0; i < element.getRest().size(); i++) {
4044      composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
4045    }
4046    for (int i = 0; i < element.getMessaging().size(); i++) {
4047      composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
4048    }
4049    for (int i = 0; i < element.getDocument().size(); i++) {
4050      composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
4051    }
4052  }
4053
4054  protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
4055    if (element == null) 
4056      return;
4057    Complex t;
4058    if (Utilities.noString(parentType))
4059      t = parent;
4060    else {
4061      t = parent.predicate("fhir:"+name,index > -1);
4062    }
4063    composeBackboneElement(t, "software", name, element, index);
4064    if (element.hasNameElement()) {
4065      composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1);
4066    }
4067    if (element.hasVersionElement()) {
4068      composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1);
4069    }
4070    if (element.hasReleaseDateElement()) {
4071      composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1);
4072    }
4073  }
4074
4075  protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
4076    if (element == null) 
4077      return;
4078    Complex t;
4079    if (Utilities.noString(parentType))
4080      t = parent;
4081    else {
4082      t = parent.predicate("fhir:"+name,index > -1);
4083    }
4084    composeBackboneElement(t, "implementation", name, element, index);
4085    if (element.hasDescriptionElement()) {
4086      composeMarkdown(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1);
4087    }
4088    if (element.hasUrlElement()) {
4089      composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1);
4090    }
4091    if (element.hasCustodian()) {
4092      composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1);
4093    }
4094  }
4095
4096  protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
4097    if (element == null) 
4098      return;
4099    Complex t;
4100    if (Utilities.noString(parentType))
4101      t = parent;
4102    else {
4103      t = parent.predicate("fhir:"+name,index > -1);
4104    }
4105    composeBackboneElement(t, "rest", name, element, index);
4106    if (element.hasModeElement()) {
4107      composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1);
4108    }
4109    if (element.hasDocumentationElement()) {
4110      composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1);
4111    }
4112    if (element.hasSecurity()) {
4113      composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1);
4114    }
4115    for (int i = 0; i < element.getResource().size(); i++) {
4116      composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i);
4117    }
4118    for (int i = 0; i < element.getInteraction().size(); i++) {
4119      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i);
4120    }
4121    for (int i = 0; i < element.getSearchParam().size(); i++) {
4122      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i);
4123    }
4124    for (int i = 0; i < element.getOperation().size(); i++) {
4125      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i);
4126    }
4127    for (int i = 0; i < element.getCompartment().size(); i++) {
4128      composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i);
4129    }
4130  }
4131
4132  protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
4133    if (element == null) 
4134      return;
4135    Complex t;
4136    if (Utilities.noString(parentType))
4137      t = parent;
4138    else {
4139      t = parent.predicate("fhir:"+name,index > -1);
4140    }
4141    composeBackboneElement(t, "security", name, element, index);
4142    if (element.hasCorsElement()) {
4143      composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1);
4144    }
4145    for (int i = 0; i < element.getService().size(); i++) {
4146      composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i);
4147    }
4148    if (element.hasDescriptionElement()) {
4149      composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1);
4150    }
4151  }
4152
4153  protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
4154    if (element == null) 
4155      return;
4156    Complex t;
4157    if (Utilities.noString(parentType))
4158      t = parent;
4159    else {
4160      t = parent.predicate("fhir:"+name,index > -1);
4161    }
4162    composeBackboneElement(t, "resource", name, element, index);
4163    if (element.hasTypeElement()) {
4164      composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1);
4165    }
4166    if (element.hasProfileElement()) {
4167      composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1);
4168    }
4169    for (int i = 0; i < element.getSupportedProfile().size(); i++) {
4170      composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i);
4171    }
4172    if (element.hasDocumentationElement()) {
4173      composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1);
4174    }
4175    for (int i = 0; i < element.getInteraction().size(); i++) {
4176      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i);
4177    }
4178    if (element.hasVersioningElement()) {
4179      composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1);
4180    }
4181    if (element.hasReadHistoryElement()) {
4182      composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1);
4183    }
4184    if (element.hasUpdateCreateElement()) {
4185      composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1);
4186    }
4187    if (element.hasConditionalCreateElement()) {
4188      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1);
4189    }
4190    if (element.hasConditionalReadElement()) {
4191      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1);
4192    }
4193    if (element.hasConditionalUpdateElement()) {
4194      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
4195    }
4196    if (element.hasConditionalPatchElement()) {
4197      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalPatch", element.getConditionalPatchElement(), -1);
4198    }
4199    if (element.hasConditionalDeleteElement()) {
4200      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1);
4201    }
4202    for (int i = 0; i < element.getReferencePolicy().size(); i++) {
4203      composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i);
4204    }
4205    for (int i = 0; i < element.getSearchInclude().size(); i++) {
4206      composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i);
4207    }
4208    for (int i = 0; i < element.getSearchRevInclude().size(); i++) {
4209      composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i);
4210    }
4211    for (int i = 0; i < element.getSearchParam().size(); i++) {
4212      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i);
4213    }
4214    for (int i = 0; i < element.getOperation().size(); i++) {
4215      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i);
4216    }
4217  }
4218
4219  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
4220    if (element == null) 
4221      return;
4222    Complex t;
4223    if (Utilities.noString(parentType))
4224      t = parent;
4225    else {
4226      t = parent.predicate("fhir:"+name,index > -1);
4227    }
4228    composeBackboneElement(t, "interaction", name, element, index);
4229    if (element.hasCodeElement()) {
4230      composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1);
4231    }
4232    if (element.hasDocumentationElement()) {
4233      composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1);
4234    }
4235  }
4236
4237  protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
4238    if (element == null) 
4239      return;
4240    Complex t;
4241    if (Utilities.noString(parentType))
4242      t = parent;
4243    else {
4244      t = parent.predicate("fhir:"+name,index > -1);
4245    }
4246    composeBackboneElement(t, "searchParam", name, element, index);
4247    if (element.hasNameElement()) {
4248      composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1);
4249    }
4250    if (element.hasDefinitionElement()) {
4251      composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1);
4252    }
4253    if (element.hasTypeElement()) {
4254      composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1);
4255    }
4256    if (element.hasDocumentationElement()) {
4257      composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1);
4258    }
4259  }
4260
4261  protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) {
4262    if (element == null) 
4263      return;
4264    Complex t;
4265    if (Utilities.noString(parentType))
4266      t = parent;
4267    else {
4268      t = parent.predicate("fhir:"+name,index > -1);
4269    }
4270    composeBackboneElement(t, "operation", name, element, index);
4271    if (element.hasNameElement()) {
4272      composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1);
4273    }
4274    if (element.hasDefinitionElement()) {
4275      composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1);
4276    }
4277    if (element.hasDocumentationElement()) {
4278      composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1);
4279    }
4280  }
4281
4282  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
4283    if (element == null) 
4284      return;
4285    Complex t;
4286    if (Utilities.noString(parentType))
4287      t = parent;
4288    else {
4289      t = parent.predicate("fhir:"+name,index > -1);
4290    }
4291    composeBackboneElement(t, "interaction", name, element, index);
4292    if (element.hasCodeElement()) {
4293      composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1);
4294    }
4295    if (element.hasDocumentationElement()) {
4296      composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1);
4297    }
4298  }
4299
4300  protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
4301    if (element == null) 
4302      return;
4303    Complex t;
4304    if (Utilities.noString(parentType))
4305      t = parent;
4306    else {
4307      t = parent.predicate("fhir:"+name,index > -1);
4308    }
4309    composeBackboneElement(t, "messaging", name, element, index);
4310    for (int i = 0; i < element.getEndpoint().size(); i++) {
4311      composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i);
4312    }
4313    if (element.hasReliableCacheElement()) {
4314      composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1);
4315    }
4316    if (element.hasDocumentationElement()) {
4317      composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1);
4318    }
4319    for (int i = 0; i < element.getSupportedMessage().size(); i++) {
4320      composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i);
4321    }
4322  }
4323
4324  protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
4325    if (element == null) 
4326      return;
4327    Complex t;
4328    if (Utilities.noString(parentType))
4329      t = parent;
4330    else {
4331      t = parent.predicate("fhir:"+name,index > -1);
4332    }
4333    composeBackboneElement(t, "endpoint", name, element, index);
4334    if (element.hasProtocol()) {
4335      composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1);
4336    }
4337    if (element.hasAddressElement()) {
4338      composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1);
4339    }
4340  }
4341
4342  protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
4343    if (element == null) 
4344      return;
4345    Complex t;
4346    if (Utilities.noString(parentType))
4347      t = parent;
4348    else {
4349      t = parent.predicate("fhir:"+name,index > -1);
4350    }
4351    composeBackboneElement(t, "supportedMessage", name, element, index);
4352    if (element.hasModeElement()) {
4353      composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1);
4354    }
4355    if (element.hasDefinitionElement()) {
4356      composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1);
4357    }
4358  }
4359
4360  protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
4361    if (element == null) 
4362      return;
4363    Complex t;
4364    if (Utilities.noString(parentType))
4365      t = parent;
4366    else {
4367      t = parent.predicate("fhir:"+name,index > -1);
4368    }
4369    composeBackboneElement(t, "document", name, element, index);
4370    if (element.hasModeElement()) {
4371      composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1);
4372    }
4373    if (element.hasDocumentationElement()) {
4374      composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1);
4375    }
4376    if (element.hasProfileElement()) {
4377      composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1);
4378    }
4379  }
4380
4381  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
4382    if (element == null) 
4383      return;
4384    Complex t;
4385    if (Utilities.noString(parentType))
4386      t = parent;
4387    else {
4388      t = parent.predicate("fhir:"+name,index > -1);
4389    }
4390    composeDomainResource(t, "CarePlan", name, element, index);
4391    for (int i = 0; i < element.getIdentifier().size(); i++) {
4392      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
4393    }
4394    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
4395      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
4396    }
4397    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
4398      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
4399    }
4400    for (int i = 0; i < element.getBasedOn().size(); i++) {
4401      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
4402    }
4403    for (int i = 0; i < element.getReplaces().size(); i++) {
4404      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
4405    }
4406    for (int i = 0; i < element.getPartOf().size(); i++) {
4407      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
4408    }
4409    if (element.hasStatusElement()) {
4410      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
4411    }
4412    if (element.hasIntentElement()) {
4413      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
4414    }
4415    for (int i = 0; i < element.getCategory().size(); i++) {
4416      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
4417    }
4418    if (element.hasTitleElement()) {
4419      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
4420    }
4421    if (element.hasDescriptionElement()) {
4422      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
4423    }
4424    if (element.hasSubject()) {
4425      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
4426    }
4427    if (element.hasEncounter()) {
4428      composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1);
4429    }
4430    if (element.hasPeriod()) {
4431      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
4432    }
4433    if (element.hasCreatedElement()) {
4434      composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1);
4435    }
4436    if (element.hasCustodian()) {
4437      composeReference(t, "CarePlan", "custodian", element.getCustodian(), -1);
4438    }
4439    for (int i = 0; i < element.getContributor().size(); i++) {
4440      composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i);
4441    }
4442    for (int i = 0; i < element.getCareTeam().size(); i++) {
4443      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
4444    }
4445    for (int i = 0; i < element.getAddresses().size(); i++) {
4446      composeCodeableReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
4447    }
4448    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
4449      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
4450    }
4451    for (int i = 0; i < element.getGoal().size(); i++) {
4452      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
4453    }
4454    for (int i = 0; i < element.getActivity().size(); i++) {
4455      composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
4456    }
4457    for (int i = 0; i < element.getNote().size(); i++) {
4458      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
4459    }
4460  }
4461
4462  protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
4463    if (element == null) 
4464      return;
4465    Complex t;
4466    if (Utilities.noString(parentType))
4467      t = parent;
4468    else {
4469      t = parent.predicate("fhir:"+name,index > -1);
4470    }
4471    composeBackboneElement(t, "activity", name, element, index);
4472    for (int i = 0; i < element.getPerformedActivity().size(); i++) {
4473      composeCodeableReference(t, "CarePlanActivityComponent", "performedActivity", element.getPerformedActivity().get(i), i);
4474    }
4475    for (int i = 0; i < element.getProgress().size(); i++) {
4476      composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i);
4477    }
4478    if (element.hasPlannedActivityReference()) {
4479      composeReference(t, "CarePlanActivityComponent", "plannedActivityReference", element.getPlannedActivityReference(), -1);
4480    }
4481  }
4482
4483  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
4484    if (element == null) 
4485      return;
4486    Complex t;
4487    if (Utilities.noString(parentType))
4488      t = parent;
4489    else {
4490      t = parent.predicate("fhir:"+name,index > -1);
4491    }
4492    composeDomainResource(t, "CareTeam", name, element, index);
4493    for (int i = 0; i < element.getIdentifier().size(); i++) {
4494      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
4495    }
4496    if (element.hasStatusElement()) {
4497      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
4498    }
4499    for (int i = 0; i < element.getCategory().size(); i++) {
4500      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
4501    }
4502    if (element.hasNameElement()) {
4503      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
4504    }
4505    if (element.hasSubject()) {
4506      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
4507    }
4508    if (element.hasPeriod()) {
4509      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
4510    }
4511    for (int i = 0; i < element.getParticipant().size(); i++) {
4512      composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
4513    }
4514    for (int i = 0; i < element.getReason().size(); i++) {
4515      composeCodeableReference(t, "CareTeam", "reason", element.getReason().get(i), i);
4516    }
4517    for (int i = 0; i < element.getManagingOrganization().size(); i++) {
4518      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
4519    }
4520    for (int i = 0; i < element.getTelecom().size(); i++) {
4521      composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i);
4522    }
4523    for (int i = 0; i < element.getNote().size(); i++) {
4524      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
4525    }
4526  }
4527
4528  protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
4529    if (element == null) 
4530      return;
4531    Complex t;
4532    if (Utilities.noString(parentType))
4533      t = parent;
4534    else {
4535      t = parent.predicate("fhir:"+name,index > -1);
4536    }
4537    composeBackboneElement(t, "participant", name, element, index);
4538    if (element.hasRole()) {
4539      composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole(), -1);
4540    }
4541    if (element.hasMember()) {
4542      composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1);
4543    }
4544    if (element.hasOnBehalfOf()) {
4545      composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
4546    }
4547    if (element.hasCoverage()) {
4548      composeType(t, "CareTeamParticipantComponent", "coverage", element.getCoverage(), -1);
4549    }
4550  }
4551
4552  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
4553    if (element == null) 
4554      return;
4555    Complex t;
4556    if (Utilities.noString(parentType))
4557      t = parent;
4558    else {
4559      t = parent.predicate("fhir:"+name,index > -1);
4560    }
4561    composeDomainResource(t, "ChargeItem", name, element, index);
4562    for (int i = 0; i < element.getIdentifier().size(); i++) {
4563      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i);
4564    }
4565    for (int i = 0; i < element.getDefinitionUri().size(); i++) {
4566      composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i);
4567    }
4568    for (int i = 0; i < element.getDefinitionCanonical().size(); i++) {
4569      composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i);
4570    }
4571    if (element.hasStatusElement()) {
4572      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
4573    }
4574    for (int i = 0; i < element.getPartOf().size(); i++) {
4575      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
4576    }
4577    if (element.hasCode()) {
4578      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
4579    }
4580    if (element.hasSubject()) {
4581      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
4582    }
4583    if (element.hasEncounter()) {
4584      composeReference(t, "ChargeItem", "encounter", element.getEncounter(), -1);
4585    }
4586    if (element.hasOccurrence()) {
4587      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
4588    }
4589    for (int i = 0; i < element.getPerformer().size(); i++) {
4590      composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i);
4591    }
4592    if (element.hasPerformingOrganization()) {
4593      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
4594    }
4595    if (element.hasRequestingOrganization()) {
4596      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
4597    }
4598    if (element.hasCostCenter()) {
4599      composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1);
4600    }
4601    if (element.hasQuantity()) {
4602      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
4603    }
4604    for (int i = 0; i < element.getBodysite().size(); i++) {
4605      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
4606    }
4607    if (element.hasUnitPriceComponent()) {
4608      composeMonetaryComponent(t, "ChargeItem", "unitPriceComponent", element.getUnitPriceComponent(), -1);
4609    }
4610    if (element.hasTotalPriceComponent()) {
4611      composeMonetaryComponent(t, "ChargeItem", "totalPriceComponent", element.getTotalPriceComponent(), -1);
4612    }
4613    if (element.hasOverrideReason()) {
4614      composeCodeableConcept(t, "ChargeItem", "overrideReason", element.getOverrideReason(), -1);
4615    }
4616    if (element.hasEnterer()) {
4617      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
4618    }
4619    if (element.hasEnteredDateElement()) {
4620      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
4621    }
4622    for (int i = 0; i < element.getReason().size(); i++) {
4623      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
4624    }
4625    for (int i = 0; i < element.getService().size(); i++) {
4626      composeCodeableReference(t, "ChargeItem", "service", element.getService().get(i), i);
4627    }
4628    for (int i = 0; i < element.getProduct().size(); i++) {
4629      composeCodeableReference(t, "ChargeItem", "product", element.getProduct().get(i), i);
4630    }
4631    for (int i = 0; i < element.getAccount().size(); i++) {
4632      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
4633    }
4634    for (int i = 0; i < element.getNote().size(); i++) {
4635      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
4636    }
4637    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
4638      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
4639    }
4640  }
4641
4642  protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) {
4643    if (element == null) 
4644      return;
4645    Complex t;
4646    if (Utilities.noString(parentType))
4647      t = parent;
4648    else {
4649      t = parent.predicate("fhir:"+name,index > -1);
4650    }
4651    composeBackboneElement(t, "performer", name, element, index);
4652    if (element.hasFunction()) {
4653      composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1);
4654    }
4655    if (element.hasActor()) {
4656      composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1);
4657    }
4658  }
4659
4660  protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) {
4661    if (element == null) 
4662      return;
4663    Complex t;
4664    if (Utilities.noString(parentType))
4665      t = parent;
4666    else {
4667      t = parent.predicate("fhir:"+name,index > -1);
4668    }
4669    composeMetadataResource(t, "ChargeItemDefinition", name, element, index);
4670    if (element.hasUrlElement()) {
4671      composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1);
4672    }
4673    for (int i = 0; i < element.getIdentifier().size(); i++) {
4674      composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i);
4675    }
4676    if (element.hasVersionElement()) {
4677      composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1);
4678    }
4679    if (element.hasVersionAlgorithm()) {
4680      composeType(t, "ChargeItemDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
4681    }
4682    if (element.hasNameElement()) {
4683      composeString(t, "ChargeItemDefinition", "name", element.getNameElement(), -1);
4684    }
4685    if (element.hasTitleElement()) {
4686      composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1);
4687    }
4688    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
4689      composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
4690    }
4691    for (int i = 0; i < element.getPartOf().size(); i++) {
4692      composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i);
4693    }
4694    for (int i = 0; i < element.getReplaces().size(); i++) {
4695      composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i);
4696    }
4697    if (element.hasStatusElement()) {
4698      composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1);
4699    }
4700    if (element.hasExperimentalElement()) {
4701      composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1);
4702    }
4703    if (element.hasDateElement()) {
4704      composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1);
4705    }
4706    if (element.hasPublisherElement()) {
4707      composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1);
4708    }
4709    for (int i = 0; i < element.getContact().size(); i++) {
4710      composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i);
4711    }
4712    if (element.hasDescriptionElement()) {
4713      composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
4714    }
4715    for (int i = 0; i < element.getUseContext().size(); i++) {
4716      composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i);
4717    }
4718    for (int i = 0; i < element.getJurisdiction().size(); i++) {
4719      composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
4720    }
4721    if (element.hasPurposeElement()) {
4722      composeMarkdown(t, "ChargeItemDefinition", "purpose", element.getPurposeElement(), -1);
4723    }
4724    if (element.hasCopyrightElement()) {
4725      composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1);
4726    }
4727    if (element.hasCopyrightLabelElement()) {
4728      composeString(t, "ChargeItemDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1);
4729    }
4730    if (element.hasApprovalDateElement()) {
4731      composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1);
4732    }
4733    if (element.hasLastReviewDateElement()) {
4734      composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
4735    }
4736    if (element.hasCode()) {
4737      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
4738    }
4739    for (int i = 0; i < element.getInstance().size(); i++) {
4740      composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i);
4741    }
4742    for (int i = 0; i < element.getApplicability().size(); i++) {
4743      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
4744    }
4745    for (int i = 0; i < element.getPropertyGroup().size(); i++) {
4746      composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i);
4747    }
4748  }
4749
4750  protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) {
4751    if (element == null) 
4752      return;
4753    Complex t;
4754    if (Utilities.noString(parentType))
4755      t = parent;
4756    else {
4757      t = parent.predicate("fhir:"+name,index > -1);
4758    }
4759    composeBackboneElement(t, "applicability", name, element, index);
4760    if (element.hasCondition()) {
4761      composeExpression(t, "ChargeItemDefinitionApplicabilityComponent", "condition", element.getCondition(), -1);
4762    }
4763    if (element.hasEffectivePeriod()) {
4764      composePeriod(t, "ChargeItemDefinitionApplicabilityComponent", "effectivePeriod", element.getEffectivePeriod(), -1);
4765    }
4766    if (element.hasRelatedArtifact()) {
4767      composeRelatedArtifact(t, "ChargeItemDefinitionApplicabilityComponent", "relatedArtifact", element.getRelatedArtifact(), -1);
4768    }
4769  }
4770
4771  protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) {
4772    if (element == null) 
4773      return;
4774    Complex t;
4775    if (Utilities.noString(parentType))
4776      t = parent;
4777    else {
4778      t = parent.predicate("fhir:"+name,index > -1);
4779    }
4780    composeBackboneElement(t, "propertyGroup", name, element, index);
4781    for (int i = 0; i < element.getApplicability().size(); i++) {
4782      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i);
4783    }
4784    for (int i = 0; i < element.getPriceComponent().size(); i++) {
4785      composeMonetaryComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i);
4786    }
4787  }
4788
4789  protected void composeCitation(Complex parent, String parentType, String name, Citation element, int index) {
4790    if (element == null) 
4791      return;
4792    Complex t;
4793    if (Utilities.noString(parentType))
4794      t = parent;
4795    else {
4796      t = parent.predicate("fhir:"+name,index > -1);
4797    }
4798    composeMetadataResource(t, "Citation", name, element, index);
4799    if (element.hasUrlElement()) {
4800      composeUri(t, "Citation", "url", element.getUrlElement(), -1);
4801    }
4802    for (int i = 0; i < element.getIdentifier().size(); i++) {
4803      composeIdentifier(t, "Citation", "identifier", element.getIdentifier().get(i), i);
4804    }
4805    if (element.hasVersionElement()) {
4806      composeString(t, "Citation", "version", element.getVersionElement(), -1);
4807    }
4808    if (element.hasVersionAlgorithm()) {
4809      composeType(t, "Citation", "versionAlgorithm", element.getVersionAlgorithm(), -1);
4810    }
4811    if (element.hasNameElement()) {
4812      composeString(t, "Citation", "name", element.getNameElement(), -1);
4813    }
4814    if (element.hasTitleElement()) {
4815      composeString(t, "Citation", "title", element.getTitleElement(), -1);
4816    }
4817    if (element.hasStatusElement()) {
4818      composeEnum(t, "Citation", "status", element.getStatusElement(), -1);
4819    }
4820    if (element.hasExperimentalElement()) {
4821      composeBoolean(t, "Citation", "experimental", element.getExperimentalElement(), -1);
4822    }
4823    if (element.hasDateElement()) {
4824      composeDateTime(t, "Citation", "date", element.getDateElement(), -1);
4825    }
4826    if (element.hasPublisherElement()) {
4827      composeString(t, "Citation", "publisher", element.getPublisherElement(), -1);
4828    }
4829    for (int i = 0; i < element.getContact().size(); i++) {
4830      composeContactDetail(t, "Citation", "contact", element.getContact().get(i), i);
4831    }
4832    if (element.hasDescriptionElement()) {
4833      composeMarkdown(t, "Citation", "description", element.getDescriptionElement(), -1);
4834    }
4835    for (int i = 0; i < element.getUseContext().size(); i++) {
4836      composeUsageContext(t, "Citation", "useContext", element.getUseContext().get(i), i);
4837    }
4838    for (int i = 0; i < element.getJurisdiction().size(); i++) {
4839      composeCodeableConcept(t, "Citation", "jurisdiction", element.getJurisdiction().get(i), i);
4840    }
4841    if (element.hasPurposeElement()) {
4842      composeMarkdown(t, "Citation", "purpose", element.getPurposeElement(), -1);
4843    }
4844    if (element.hasCopyrightElement()) {
4845      composeMarkdown(t, "Citation", "copyright", element.getCopyrightElement(), -1);
4846    }
4847    if (element.hasCopyrightLabelElement()) {
4848      composeString(t, "Citation", "copyrightLabel", element.getCopyrightLabelElement(), -1);
4849    }
4850    if (element.hasApprovalDateElement()) {
4851      composeDate(t, "Citation", "approvalDate", element.getApprovalDateElement(), -1);
4852    }
4853    if (element.hasLastReviewDateElement()) {
4854      composeDate(t, "Citation", "lastReviewDate", element.getLastReviewDateElement(), -1);
4855    }
4856    if (element.hasEffectivePeriod()) {
4857      composePeriod(t, "Citation", "effectivePeriod", element.getEffectivePeriod(), -1);
4858    }
4859    for (int i = 0; i < element.getAuthor().size(); i++) {
4860      composeContactDetail(t, "Citation", "author", element.getAuthor().get(i), i);
4861    }
4862    for (int i = 0; i < element.getEditor().size(); i++) {
4863      composeContactDetail(t, "Citation", "editor", element.getEditor().get(i), i);
4864    }
4865    for (int i = 0; i < element.getReviewer().size(); i++) {
4866      composeContactDetail(t, "Citation", "reviewer", element.getReviewer().get(i), i);
4867    }
4868    for (int i = 0; i < element.getEndorser().size(); i++) {
4869      composeContactDetail(t, "Citation", "endorser", element.getEndorser().get(i), i);
4870    }
4871    for (int i = 0; i < element.getSummary().size(); i++) {
4872      composeCitationSummaryComponent(t, "Citation", "summary", element.getSummary().get(i), i);
4873    }
4874    for (int i = 0; i < element.getClassification().size(); i++) {
4875      composeCitationClassificationComponent(t, "Citation", "classification", element.getClassification().get(i), i);
4876    }
4877    for (int i = 0; i < element.getNote().size(); i++) {
4878      composeAnnotation(t, "Citation", "note", element.getNote().get(i), i);
4879    }
4880    for (int i = 0; i < element.getCurrentState().size(); i++) {
4881      composeCodeableConcept(t, "Citation", "currentState", element.getCurrentState().get(i), i);
4882    }
4883    for (int i = 0; i < element.getStatusDate().size(); i++) {
4884      composeCitationStatusDateComponent(t, "Citation", "statusDate", element.getStatusDate().get(i), i);
4885    }
4886    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
4887      composeRelatedArtifact(t, "Citation", "relatedArtifact", element.getRelatedArtifact().get(i), i);
4888    }
4889    if (element.hasCitedArtifact()) {
4890      composeCitationCitedArtifactComponent(t, "Citation", "citedArtifact", element.getCitedArtifact(), -1);
4891    }
4892  }
4893
4894  protected void composeCitationSummaryComponent(Complex parent, String parentType, String name, Citation.CitationSummaryComponent element, int index) {
4895    if (element == null) 
4896      return;
4897    Complex t;
4898    if (Utilities.noString(parentType))
4899      t = parent;
4900    else {
4901      t = parent.predicate("fhir:"+name,index > -1);
4902    }
4903    composeBackboneElement(t, "summary", name, element, index);
4904    if (element.hasStyle()) {
4905      composeCodeableConcept(t, "CitationSummaryComponent", "style", element.getStyle(), -1);
4906    }
4907    if (element.hasTextElement()) {
4908      composeMarkdown(t, "CitationSummaryComponent", "text", element.getTextElement(), -1);
4909    }
4910  }
4911
4912  protected void composeCitationClassificationComponent(Complex parent, String parentType, String name, Citation.CitationClassificationComponent element, int index) {
4913    if (element == null) 
4914      return;
4915    Complex t;
4916    if (Utilities.noString(parentType))
4917      t = parent;
4918    else {
4919      t = parent.predicate("fhir:"+name,index > -1);
4920    }
4921    composeBackboneElement(t, "classification", name, element, index);
4922    if (element.hasType()) {
4923      composeCodeableConcept(t, "CitationClassificationComponent", "type", element.getType(), -1);
4924    }
4925    for (int i = 0; i < element.getClassifier().size(); i++) {
4926      composeCodeableConcept(t, "CitationClassificationComponent", "classifier", element.getClassifier().get(i), i);
4927    }
4928  }
4929
4930  protected void composeCitationStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationStatusDateComponent element, int index) {
4931    if (element == null) 
4932      return;
4933    Complex t;
4934    if (Utilities.noString(parentType))
4935      t = parent;
4936    else {
4937      t = parent.predicate("fhir:"+name,index > -1);
4938    }
4939    composeBackboneElement(t, "statusDate", name, element, index);
4940    if (element.hasActivity()) {
4941      composeCodeableConcept(t, "CitationStatusDateComponent", "activity", element.getActivity(), -1);
4942    }
4943    if (element.hasActualElement()) {
4944      composeBoolean(t, "CitationStatusDateComponent", "actual", element.getActualElement(), -1);
4945    }
4946    if (element.hasPeriod()) {
4947      composePeriod(t, "CitationStatusDateComponent", "period", element.getPeriod(), -1);
4948    }
4949  }
4950
4951  protected void composeCitationCitedArtifactComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactComponent element, int index) {
4952    if (element == null) 
4953      return;
4954    Complex t;
4955    if (Utilities.noString(parentType))
4956      t = parent;
4957    else {
4958      t = parent.predicate("fhir:"+name,index > -1);
4959    }
4960    composeBackboneElement(t, "citedArtifact", name, element, index);
4961    for (int i = 0; i < element.getIdentifier().size(); i++) {
4962      composeIdentifier(t, "CitationCitedArtifactComponent", "identifier", element.getIdentifier().get(i), i);
4963    }
4964    for (int i = 0; i < element.getRelatedIdentifier().size(); i++) {
4965      composeIdentifier(t, "CitationCitedArtifactComponent", "relatedIdentifier", element.getRelatedIdentifier().get(i), i);
4966    }
4967    if (element.hasDateAccessedElement()) {
4968      composeDateTime(t, "CitationCitedArtifactComponent", "dateAccessed", element.getDateAccessedElement(), -1);
4969    }
4970    if (element.hasVersion()) {
4971      composeCitationCitedArtifactVersionComponent(t, "CitationCitedArtifactComponent", "version", element.getVersion(), -1);
4972    }
4973    for (int i = 0; i < element.getCurrentState().size(); i++) {
4974      composeCodeableConcept(t, "CitationCitedArtifactComponent", "currentState", element.getCurrentState().get(i), i);
4975    }
4976    for (int i = 0; i < element.getStatusDate().size(); i++) {
4977      composeCitationCitedArtifactStatusDateComponent(t, "CitationCitedArtifactComponent", "statusDate", element.getStatusDate().get(i), i);
4978    }
4979    for (int i = 0; i < element.getTitle().size(); i++) {
4980      composeCitationCitedArtifactTitleComponent(t, "CitationCitedArtifactComponent", "title", element.getTitle().get(i), i);
4981    }
4982    for (int i = 0; i < element.getAbstract().size(); i++) {
4983      composeCitationCitedArtifactAbstractComponent(t, "CitationCitedArtifactComponent", "abstract", element.getAbstract().get(i), i);
4984    }
4985    if (element.hasPart()) {
4986      composeCitationCitedArtifactPartComponent(t, "CitationCitedArtifactComponent", "part", element.getPart(), -1);
4987    }
4988    for (int i = 0; i < element.getRelatesTo().size(); i++) {
4989      composeCitationCitedArtifactRelatesToComponent(t, "CitationCitedArtifactComponent", "relatesTo", element.getRelatesTo().get(i), i);
4990    }
4991    for (int i = 0; i < element.getPublicationForm().size(); i++) {
4992      composeCitationCitedArtifactPublicationFormComponent(t, "CitationCitedArtifactComponent", "publicationForm", element.getPublicationForm().get(i), i);
4993    }
4994    for (int i = 0; i < element.getWebLocation().size(); i++) {
4995      composeCitationCitedArtifactWebLocationComponent(t, "CitationCitedArtifactComponent", "webLocation", element.getWebLocation().get(i), i);
4996    }
4997    for (int i = 0; i < element.getClassification().size(); i++) {
4998      composeCitationCitedArtifactClassificationComponent(t, "CitationCitedArtifactComponent", "classification", element.getClassification().get(i), i);
4999    }
5000    if (element.hasContributorship()) {
5001      composeCitationCitedArtifactContributorshipComponent(t, "CitationCitedArtifactComponent", "contributorship", element.getContributorship(), -1);
5002    }
5003    for (int i = 0; i < element.getNote().size(); i++) {
5004      composeAnnotation(t, "CitationCitedArtifactComponent", "note", element.getNote().get(i), i);
5005    }
5006  }
5007
5008  protected void composeCitationCitedArtifactVersionComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactVersionComponent element, int index) {
5009    if (element == null) 
5010      return;
5011    Complex t;
5012    if (Utilities.noString(parentType))
5013      t = parent;
5014    else {
5015      t = parent.predicate("fhir:"+name,index > -1);
5016    }
5017    composeBackboneElement(t, "version", name, element, index);
5018    if (element.hasValueElement()) {
5019      composeString(t, "CitationCitedArtifactVersionComponent", "value", element.getValueElement(), -1);
5020    }
5021    if (element.hasBaseCitation()) {
5022      composeReference(t, "CitationCitedArtifactVersionComponent", "baseCitation", element.getBaseCitation(), -1);
5023    }
5024  }
5025
5026  protected void composeCitationCitedArtifactStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactStatusDateComponent element, int index) {
5027    if (element == null) 
5028      return;
5029    Complex t;
5030    if (Utilities.noString(parentType))
5031      t = parent;
5032    else {
5033      t = parent.predicate("fhir:"+name,index > -1);
5034    }
5035    composeBackboneElement(t, "statusDate", name, element, index);
5036    if (element.hasActivity()) {
5037      composeCodeableConcept(t, "CitationCitedArtifactStatusDateComponent", "activity", element.getActivity(), -1);
5038    }
5039    if (element.hasActualElement()) {
5040      composeBoolean(t, "CitationCitedArtifactStatusDateComponent", "actual", element.getActualElement(), -1);
5041    }
5042    if (element.hasPeriod()) {
5043      composePeriod(t, "CitationCitedArtifactStatusDateComponent", "period", element.getPeriod(), -1);
5044    }
5045  }
5046
5047  protected void composeCitationCitedArtifactTitleComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactTitleComponent element, int index) {
5048    if (element == null) 
5049      return;
5050    Complex t;
5051    if (Utilities.noString(parentType))
5052      t = parent;
5053    else {
5054      t = parent.predicate("fhir:"+name,index > -1);
5055    }
5056    composeBackboneElement(t, "title", name, element, index);
5057    for (int i = 0; i < element.getType().size(); i++) {
5058      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "type", element.getType().get(i), i);
5059    }
5060    if (element.hasLanguage()) {
5061      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "language", element.getLanguage(), -1);
5062    }
5063    if (element.hasTextElement()) {
5064      composeMarkdown(t, "CitationCitedArtifactTitleComponent", "text", element.getTextElement(), -1);
5065    }
5066  }
5067
5068  protected void composeCitationCitedArtifactAbstractComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactAbstractComponent element, int index) {
5069    if (element == null) 
5070      return;
5071    Complex t;
5072    if (Utilities.noString(parentType))
5073      t = parent;
5074    else {
5075      t = parent.predicate("fhir:"+name,index > -1);
5076    }
5077    composeBackboneElement(t, "abstract", name, element, index);
5078    if (element.hasType()) {
5079      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "type", element.getType(), -1);
5080    }
5081    if (element.hasLanguage()) {
5082      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "language", element.getLanguage(), -1);
5083    }
5084    if (element.hasTextElement()) {
5085      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "text", element.getTextElement(), -1);
5086    }
5087    if (element.hasCopyrightElement()) {
5088      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "copyright", element.getCopyrightElement(), -1);
5089    }
5090  }
5091
5092  protected void composeCitationCitedArtifactPartComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPartComponent element, int index) {
5093    if (element == null) 
5094      return;
5095    Complex t;
5096    if (Utilities.noString(parentType))
5097      t = parent;
5098    else {
5099      t = parent.predicate("fhir:"+name,index > -1);
5100    }
5101    composeBackboneElement(t, "part", name, element, index);
5102    if (element.hasType()) {
5103      composeCodeableConcept(t, "CitationCitedArtifactPartComponent", "type", element.getType(), -1);
5104    }
5105    if (element.hasValueElement()) {
5106      composeString(t, "CitationCitedArtifactPartComponent", "value", element.getValueElement(), -1);
5107    }
5108    if (element.hasBaseCitation()) {
5109      composeReference(t, "CitationCitedArtifactPartComponent", "baseCitation", element.getBaseCitation(), -1);
5110    }
5111  }
5112
5113  protected void composeCitationCitedArtifactRelatesToComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactRelatesToComponent element, int index) {
5114    if (element == null) 
5115      return;
5116    Complex t;
5117    if (Utilities.noString(parentType))
5118      t = parent;
5119    else {
5120      t = parent.predicate("fhir:"+name,index > -1);
5121    }
5122    composeBackboneElement(t, "relatesTo", name, element, index);
5123    if (element.hasTypeElement()) {
5124      composeEnum(t, "CitationCitedArtifactRelatesToComponent", "type", element.getTypeElement(), -1);
5125    }
5126    for (int i = 0; i < element.getClassifier().size(); i++) {
5127      composeCodeableConcept(t, "CitationCitedArtifactRelatesToComponent", "classifier", element.getClassifier().get(i), i);
5128    }
5129    if (element.hasLabelElement()) {
5130      composeString(t, "CitationCitedArtifactRelatesToComponent", "label", element.getLabelElement(), -1);
5131    }
5132    if (element.hasDisplayElement()) {
5133      composeString(t, "CitationCitedArtifactRelatesToComponent", "display", element.getDisplayElement(), -1);
5134    }
5135    if (element.hasCitationElement()) {
5136      composeMarkdown(t, "CitationCitedArtifactRelatesToComponent", "citation", element.getCitationElement(), -1);
5137    }
5138    if (element.hasDocument()) {
5139      composeAttachment(t, "CitationCitedArtifactRelatesToComponent", "document", element.getDocument(), -1);
5140    }
5141    if (element.hasResourceElement()) {
5142      composeCanonical(t, "CitationCitedArtifactRelatesToComponent", "resource", element.getResourceElement(), -1);
5143    }
5144    if (element.hasResourceReference()) {
5145      composeReference(t, "CitationCitedArtifactRelatesToComponent", "resourceReference", element.getResourceReference(), -1);
5146    }
5147  }
5148
5149  protected void composeCitationCitedArtifactPublicationFormComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormComponent element, int index) {
5150    if (element == null) 
5151      return;
5152    Complex t;
5153    if (Utilities.noString(parentType))
5154      t = parent;
5155    else {
5156      t = parent.predicate("fhir:"+name,index > -1);
5157    }
5158    composeBackboneElement(t, "publicationForm", name, element, index);
5159    if (element.hasPublishedIn()) {
5160      composeCitationCitedArtifactPublicationFormPublishedInComponent(t, "CitationCitedArtifactPublicationFormComponent", "publishedIn", element.getPublishedIn(), -1);
5161    }
5162    if (element.hasCitedMedium()) {
5163      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "citedMedium", element.getCitedMedium(), -1);
5164    }
5165    if (element.hasVolumeElement()) {
5166      composeString(t, "CitationCitedArtifactPublicationFormComponent", "volume", element.getVolumeElement(), -1);
5167    }
5168    if (element.hasIssueElement()) {
5169      composeString(t, "CitationCitedArtifactPublicationFormComponent", "issue", element.getIssueElement(), -1);
5170    }
5171    if (element.hasArticleDateElement()) {
5172      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "articleDate", element.getArticleDateElement(), -1);
5173    }
5174    if (element.hasPublicationDateTextElement()) {
5175      composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateText", element.getPublicationDateTextElement(), -1);
5176    }
5177    if (element.hasPublicationDateSeasonElement()) {
5178      composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateSeason", element.getPublicationDateSeasonElement(), -1);
5179    }
5180    if (element.hasLastRevisionDateElement()) {
5181      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "lastRevisionDate", element.getLastRevisionDateElement(), -1);
5182    }
5183    for (int i = 0; i < element.getLanguage().size(); i++) {
5184      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "language", element.getLanguage().get(i), i);
5185    }
5186    if (element.hasAccessionNumberElement()) {
5187      composeString(t, "CitationCitedArtifactPublicationFormComponent", "accessionNumber", element.getAccessionNumberElement(), -1);
5188    }
5189    if (element.hasPageStringElement()) {
5190      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageString", element.getPageStringElement(), -1);
5191    }
5192    if (element.hasFirstPageElement()) {
5193      composeString(t, "CitationCitedArtifactPublicationFormComponent", "firstPage", element.getFirstPageElement(), -1);
5194    }
5195    if (element.hasLastPageElement()) {
5196      composeString(t, "CitationCitedArtifactPublicationFormComponent", "lastPage", element.getLastPageElement(), -1);
5197    }
5198    if (element.hasPageCountElement()) {
5199      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageCount", element.getPageCountElement(), -1);
5200    }
5201    if (element.hasCopyrightElement()) {
5202      composeMarkdown(t, "CitationCitedArtifactPublicationFormComponent", "copyright", element.getCopyrightElement(), -1);
5203    }
5204  }
5205
5206  protected void composeCitationCitedArtifactPublicationFormPublishedInComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPublishedInComponent element, int index) {
5207    if (element == null) 
5208      return;
5209    Complex t;
5210    if (Utilities.noString(parentType))
5211      t = parent;
5212    else {
5213      t = parent.predicate("fhir:"+name,index > -1);
5214    }
5215    composeBackboneElement(t, "publishedIn", name, element, index);
5216    if (element.hasType()) {
5217      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "type", element.getType(), -1);
5218    }
5219    for (int i = 0; i < element.getIdentifier().size(); i++) {
5220      composeIdentifier(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "identifier", element.getIdentifier().get(i), i);
5221    }
5222    if (element.hasTitleElement()) {
5223      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "title", element.getTitleElement(), -1);
5224    }
5225    if (element.hasPublisher()) {
5226      composeReference(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisher", element.getPublisher(), -1);
5227    }
5228    if (element.hasPublisherLocationElement()) {
5229      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisherLocation", element.getPublisherLocationElement(), -1);
5230    }
5231  }
5232
5233  protected void composeCitationCitedArtifactWebLocationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactWebLocationComponent element, int index) {
5234    if (element == null) 
5235      return;
5236    Complex t;
5237    if (Utilities.noString(parentType))
5238      t = parent;
5239    else {
5240      t = parent.predicate("fhir:"+name,index > -1);
5241    }
5242    composeBackboneElement(t, "webLocation", name, element, index);
5243    for (int i = 0; i < element.getClassifier().size(); i++) {
5244      composeCodeableConcept(t, "CitationCitedArtifactWebLocationComponent", "classifier", element.getClassifier().get(i), i);
5245    }
5246    if (element.hasUrlElement()) {
5247      composeUri(t, "CitationCitedArtifactWebLocationComponent", "url", element.getUrlElement(), -1);
5248    }
5249  }
5250
5251  protected void composeCitationCitedArtifactClassificationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactClassificationComponent element, int index) {
5252    if (element == null) 
5253      return;
5254    Complex t;
5255    if (Utilities.noString(parentType))
5256      t = parent;
5257    else {
5258      t = parent.predicate("fhir:"+name,index > -1);
5259    }
5260    composeBackboneElement(t, "classification", name, element, index);
5261    if (element.hasType()) {
5262      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "type", element.getType(), -1);
5263    }
5264    for (int i = 0; i < element.getClassifier().size(); i++) {
5265      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "classifier", element.getClassifier().get(i), i);
5266    }
5267    for (int i = 0; i < element.getArtifactAssessment().size(); i++) {
5268      composeReference(t, "CitationCitedArtifactClassificationComponent", "artifactAssessment", element.getArtifactAssessment().get(i), i);
5269    }
5270  }
5271
5272  protected void composeCitationCitedArtifactContributorshipComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipComponent element, int index) {
5273    if (element == null) 
5274      return;
5275    Complex t;
5276    if (Utilities.noString(parentType))
5277      t = parent;
5278    else {
5279      t = parent.predicate("fhir:"+name,index > -1);
5280    }
5281    composeBackboneElement(t, "contributorship", name, element, index);
5282    if (element.hasCompleteElement()) {
5283      composeBoolean(t, "CitationCitedArtifactContributorshipComponent", "complete", element.getCompleteElement(), -1);
5284    }
5285    for (int i = 0; i < element.getEntry().size(); i++) {
5286      composeCitationCitedArtifactContributorshipEntryComponent(t, "CitationCitedArtifactContributorshipComponent", "entry", element.getEntry().get(i), i);
5287    }
5288    for (int i = 0; i < element.getSummary().size(); i++) {
5289      composeCitationContributorshipSummaryComponent(t, "CitationCitedArtifactContributorshipComponent", "summary", element.getSummary().get(i), i);
5290    }
5291  }
5292
5293  protected void composeCitationCitedArtifactContributorshipEntryComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryComponent element, int index) {
5294    if (element == null) 
5295      return;
5296    Complex t;
5297    if (Utilities.noString(parentType))
5298      t = parent;
5299    else {
5300      t = parent.predicate("fhir:"+name,index > -1);
5301    }
5302    composeBackboneElement(t, "entry", name, element, index);
5303    if (element.hasContributor()) {
5304      composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "contributor", element.getContributor(), -1);
5305    }
5306    if (element.hasForenameInitialsElement()) {
5307      composeString(t, "CitationCitedArtifactContributorshipEntryComponent", "forenameInitials", element.getForenameInitialsElement(), -1);
5308    }
5309    for (int i = 0; i < element.getAffiliation().size(); i++) {
5310      composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "affiliation", element.getAffiliation().get(i), i);
5311    }
5312    for (int i = 0; i < element.getContributionType().size(); i++) {
5313      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionType", element.getContributionType().get(i), i);
5314    }
5315    if (element.hasRole()) {
5316      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "role", element.getRole(), -1);
5317    }
5318    for (int i = 0; i < element.getContributionInstance().size(); i++) {
5319      composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionInstance", element.getContributionInstance().get(i), i);
5320    }
5321    if (element.hasCorrespondingContactElement()) {
5322      composeBoolean(t, "CitationCitedArtifactContributorshipEntryComponent", "correspondingContact", element.getCorrespondingContactElement(), -1);
5323    }
5324    if (element.hasRankingOrderElement()) {
5325      composePositiveInt(t, "CitationCitedArtifactContributorshipEntryComponent", "rankingOrder", element.getRankingOrderElement(), -1);
5326    }
5327  }
5328
5329  protected void composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent element, int index) {
5330    if (element == null) 
5331      return;
5332    Complex t;
5333    if (Utilities.noString(parentType))
5334      t = parent;
5335    else {
5336      t = parent.predicate("fhir:"+name,index > -1);
5337    }
5338    composeBackboneElement(t, "contributionInstance", name, element, index);
5339    if (element.hasType()) {
5340      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "type", element.getType(), -1);
5341    }
5342    if (element.hasTimeElement()) {
5343      composeDateTime(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "time", element.getTimeElement(), -1);
5344    }
5345  }
5346
5347  protected void composeCitationContributorshipSummaryComponent(Complex parent, String parentType, String name, Citation.ContributorshipSummaryComponent element, int index) {
5348    if (element == null) 
5349      return;
5350    Complex t;
5351    if (Utilities.noString(parentType))
5352      t = parent;
5353    else {
5354      t = parent.predicate("fhir:"+name,index > -1);
5355    }
5356    composeBackboneElement(t, "summary", name, element, index);
5357    if (element.hasType()) {
5358      composeCodeableConcept(t, "ContributorshipSummaryComponent", "type", element.getType(), -1);
5359    }
5360    if (element.hasStyle()) {
5361      composeCodeableConcept(t, "ContributorshipSummaryComponent", "style", element.getStyle(), -1);
5362    }
5363    if (element.hasSource()) {
5364      composeCodeableConcept(t, "ContributorshipSummaryComponent", "source", element.getSource(), -1);
5365    }
5366    if (element.hasValueElement()) {
5367      composeMarkdown(t, "ContributorshipSummaryComponent", "value", element.getValueElement(), -1);
5368    }
5369  }
5370
5371  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
5372    if (element == null) 
5373      return;
5374    Complex t;
5375    if (Utilities.noString(parentType))
5376      t = parent;
5377    else {
5378      t = parent.predicate("fhir:"+name,index > -1);
5379    }
5380    composeDomainResource(t, "Claim", name, element, index);
5381    for (int i = 0; i < element.getIdentifier().size(); i++) {
5382      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
5383    }
5384    for (int i = 0; i < element.getTraceNumber().size(); i++) {
5385      composeIdentifier(t, "Claim", "traceNumber", element.getTraceNumber().get(i), i);
5386    }
5387    if (element.hasStatusElement()) {
5388      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
5389    }
5390    if (element.hasType()) {
5391      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
5392    }
5393    if (element.hasSubType()) {
5394      composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1);
5395    }
5396    if (element.hasUseElement()) {
5397      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
5398    }
5399    if (element.hasPatient()) {
5400      composeReference(t, "Claim", "patient", element.getPatient(), -1);
5401    }
5402    if (element.hasBillablePeriod()) {
5403      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
5404    }
5405    if (element.hasCreatedElement()) {
5406      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
5407    }
5408    if (element.hasEnterer()) {
5409      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
5410    }
5411    if (element.hasInsurer()) {
5412      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
5413    }
5414    if (element.hasProvider()) {
5415      composeReference(t, "Claim", "provider", element.getProvider(), -1);
5416    }
5417    if (element.hasPriority()) {
5418      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
5419    }
5420    if (element.hasFundsReserve()) {
5421      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
5422    }
5423    for (int i = 0; i < element.getRelated().size(); i++) {
5424      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
5425    }
5426    if (element.hasPrescription()) {
5427      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
5428    }
5429    if (element.hasOriginalPrescription()) {
5430      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
5431    }
5432    if (element.hasPayee()) {
5433      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
5434    }
5435    if (element.hasReferral()) {
5436      composeReference(t, "Claim", "referral", element.getReferral(), -1);
5437    }
5438    for (int i = 0; i < element.getEncounter().size(); i++) {
5439      composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i);
5440    }
5441    if (element.hasFacility()) {
5442      composeReference(t, "Claim", "facility", element.getFacility(), -1);
5443    }
5444    if (element.hasDiagnosisRelatedGroup()) {
5445      composeCodeableConcept(t, "Claim", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1);
5446    }
5447    for (int i = 0; i < element.getEvent().size(); i++) {
5448      composeClaimEventComponent(t, "Claim", "event", element.getEvent().get(i), i);
5449    }
5450    for (int i = 0; i < element.getCareTeam().size(); i++) {
5451      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
5452    }
5453    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
5454      composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i);
5455    }
5456    for (int i = 0; i < element.getDiagnosis().size(); i++) {
5457      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
5458    }
5459    for (int i = 0; i < element.getProcedure().size(); i++) {
5460      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
5461    }
5462    for (int i = 0; i < element.getInsurance().size(); i++) {
5463      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
5464    }
5465    if (element.hasAccident()) {
5466      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
5467    }
5468    if (element.hasPatientPaid()) {
5469      composeMoney(t, "Claim", "patientPaid", element.getPatientPaid(), -1);
5470    }
5471    for (int i = 0; i < element.getItem().size(); i++) {
5472      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
5473    }
5474    if (element.hasTotal()) {
5475      composeMoney(t, "Claim", "total", element.getTotal(), -1);
5476    }
5477  }
5478
5479  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) {
5480    if (element == null) 
5481      return;
5482    Complex t;
5483    if (Utilities.noString(parentType))
5484      t = parent;
5485    else {
5486      t = parent.predicate("fhir:"+name,index > -1);
5487    }
5488    composeBackboneElement(t, "related", name, element, index);
5489    if (element.hasClaim()) {
5490      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
5491    }
5492    if (element.hasRelationship()) {
5493      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
5494    }
5495    if (element.hasReference()) {
5496      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
5497    }
5498  }
5499
5500  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
5501    if (element == null) 
5502      return;
5503    Complex t;
5504    if (Utilities.noString(parentType))
5505      t = parent;
5506    else {
5507      t = parent.predicate("fhir:"+name,index > -1);
5508    }
5509    composeBackboneElement(t, "payee", name, element, index);
5510    if (element.hasType()) {
5511      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
5512    }
5513    if (element.hasParty()) {
5514      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
5515    }
5516  }
5517
5518  protected void composeClaimEventComponent(Complex parent, String parentType, String name, Claim.ClaimEventComponent element, int index) {
5519    if (element == null) 
5520      return;
5521    Complex t;
5522    if (Utilities.noString(parentType))
5523      t = parent;
5524    else {
5525      t = parent.predicate("fhir:"+name,index > -1);
5526    }
5527    composeBackboneElement(t, "event", name, element, index);
5528    if (element.hasType()) {
5529      composeCodeableConcept(t, "ClaimEventComponent", "type", element.getType(), -1);
5530    }
5531    if (element.hasWhen()) {
5532      composeType(t, "ClaimEventComponent", "when", element.getWhen(), -1);
5533    }
5534  }
5535
5536  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) {
5537    if (element == null) 
5538      return;
5539    Complex t;
5540    if (Utilities.noString(parentType))
5541      t = parent;
5542    else {
5543      t = parent.predicate("fhir:"+name,index > -1);
5544    }
5545    composeBackboneElement(t, "careTeam", name, element, index);
5546    if (element.hasSequenceElement()) {
5547      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
5548    }
5549    if (element.hasProvider()) {
5550      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
5551    }
5552    if (element.hasResponsibleElement()) {
5553      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
5554    }
5555    if (element.hasRole()) {
5556      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
5557    }
5558    if (element.hasSpecialty()) {
5559      composeCodeableConcept(t, "CareTeamComponent", "specialty", element.getSpecialty(), -1);
5560    }
5561  }
5562
5563  protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) {
5564    if (element == null) 
5565      return;
5566    Complex t;
5567    if (Utilities.noString(parentType))
5568      t = parent;
5569    else {
5570      t = parent.predicate("fhir:"+name,index > -1);
5571    }
5572    composeBackboneElement(t, "supportingInfo", name, element, index);
5573    if (element.hasSequenceElement()) {
5574      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
5575    }
5576    if (element.hasCategory()) {
5577      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
5578    }
5579    if (element.hasCode()) {
5580      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
5581    }
5582    if (element.hasTiming()) {
5583      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
5584    }
5585    if (element.hasValue()) {
5586      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
5587    }
5588    if (element.hasReason()) {
5589      composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
5590    }
5591  }
5592
5593  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
5594    if (element == null) 
5595      return;
5596    Complex t;
5597    if (Utilities.noString(parentType))
5598      t = parent;
5599    else {
5600      t = parent.predicate("fhir:"+name,index > -1);
5601    }
5602    composeBackboneElement(t, "diagnosis", name, element, index);
5603    if (element.hasSequenceElement()) {
5604      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
5605    }
5606    if (element.hasDiagnosis()) {
5607      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
5608    }
5609    for (int i = 0; i < element.getType().size(); i++) {
5610      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
5611    }
5612    if (element.hasOnAdmission()) {
5613      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
5614    }
5615  }
5616
5617  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
5618    if (element == null) 
5619      return;
5620    Complex t;
5621    if (Utilities.noString(parentType))
5622      t = parent;
5623    else {
5624      t = parent.predicate("fhir:"+name,index > -1);
5625    }
5626    composeBackboneElement(t, "procedure", name, element, index);
5627    if (element.hasSequenceElement()) {
5628      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
5629    }
5630    for (int i = 0; i < element.getType().size(); i++) {
5631      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
5632    }
5633    if (element.hasDateElement()) {
5634      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
5635    }
5636    if (element.hasProcedure()) {
5637      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
5638    }
5639    for (int i = 0; i < element.getUdi().size(); i++) {
5640      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
5641    }
5642  }
5643
5644  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
5645    if (element == null) 
5646      return;
5647    Complex t;
5648    if (Utilities.noString(parentType))
5649      t = parent;
5650    else {
5651      t = parent.predicate("fhir:"+name,index > -1);
5652    }
5653    composeBackboneElement(t, "insurance", name, element, index);
5654    if (element.hasSequenceElement()) {
5655      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
5656    }
5657    if (element.hasFocalElement()) {
5658      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
5659    }
5660    if (element.hasIdentifier()) {
5661      composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1);
5662    }
5663    if (element.hasCoverage()) {
5664      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
5665    }
5666    if (element.hasBusinessArrangementElement()) {
5667      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
5668    }
5669    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
5670      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
5671    }
5672    if (element.hasClaimResponse()) {
5673      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
5674    }
5675  }
5676
5677  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
5678    if (element == null) 
5679      return;
5680    Complex t;
5681    if (Utilities.noString(parentType))
5682      t = parent;
5683    else {
5684      t = parent.predicate("fhir:"+name,index > -1);
5685    }
5686    composeBackboneElement(t, "accident", name, element, index);
5687    if (element.hasDateElement()) {
5688      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
5689    }
5690    if (element.hasType()) {
5691      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
5692    }
5693    if (element.hasLocation()) {
5694      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
5695    }
5696  }
5697
5698  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) {
5699    if (element == null) 
5700      return;
5701    Complex t;
5702    if (Utilities.noString(parentType))
5703      t = parent;
5704    else {
5705      t = parent.predicate("fhir:"+name,index > -1);
5706    }
5707    composeBackboneElement(t, "item", name, element, index);
5708    if (element.hasSequenceElement()) {
5709      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
5710    }
5711    for (int i = 0; i < element.getTraceNumber().size(); i++) {
5712      composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
5713    }
5714    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
5715      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
5716    }
5717    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
5718      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
5719    }
5720    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
5721      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
5722    }
5723    for (int i = 0; i < element.getInformationSequence().size(); i++) {
5724      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
5725    }
5726    if (element.hasRevenue()) {
5727      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
5728    }
5729    if (element.hasCategory()) {
5730      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
5731    }
5732    if (element.hasProductOrService()) {
5733      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
5734    }
5735    if (element.hasProductOrServiceEnd()) {
5736      composeCodeableConcept(t, "ItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
5737    }
5738    for (int i = 0; i < element.getRequest().size(); i++) {
5739      composeReference(t, "ItemComponent", "request", element.getRequest().get(i), i);
5740    }
5741    for (int i = 0; i < element.getModifier().size(); i++) {
5742      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
5743    }
5744    for (int i = 0; i < element.getProgramCode().size(); i++) {
5745      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
5746    }
5747    if (element.hasServiced()) {
5748      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
5749    }
5750    if (element.hasLocation()) {
5751      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
5752    }
5753    if (element.hasPatientPaid()) {
5754      composeMoney(t, "ItemComponent", "patientPaid", element.getPatientPaid(), -1);
5755    }
5756    if (element.hasQuantity()) {
5757      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
5758    }
5759    if (element.hasUnitPrice()) {
5760      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
5761    }
5762    if (element.hasFactorElement()) {
5763      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
5764    }
5765    if (element.hasTax()) {
5766      composeMoney(t, "ItemComponent", "tax", element.getTax(), -1);
5767    }
5768    if (element.hasNet()) {
5769      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
5770    }
5771    for (int i = 0; i < element.getUdi().size(); i++) {
5772      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
5773    }
5774    for (int i = 0; i < element.getBodySite().size(); i++) {
5775      composeClaimBodySiteComponent(t, "ItemComponent", "bodySite", element.getBodySite().get(i), i);
5776    }
5777    for (int i = 0; i < element.getEncounter().size(); i++) {
5778      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
5779    }
5780    for (int i = 0; i < element.getDetail().size(); i++) {
5781      composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
5782    }
5783  }
5784
5785  protected void composeClaimBodySiteComponent(Complex parent, String parentType, String name, Claim.BodySiteComponent element, int index) {
5786    if (element == null) 
5787      return;
5788    Complex t;
5789    if (Utilities.noString(parentType))
5790      t = parent;
5791    else {
5792      t = parent.predicate("fhir:"+name,index > -1);
5793    }
5794    composeBackboneElement(t, "bodySite", name, element, index);
5795    for (int i = 0; i < element.getSite().size(); i++) {
5796      composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i);
5797    }
5798    for (int i = 0; i < element.getSubSite().size(); i++) {
5799      composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i);
5800    }
5801  }
5802
5803  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
5804    if (element == null) 
5805      return;
5806    Complex t;
5807    if (Utilities.noString(parentType))
5808      t = parent;
5809    else {
5810      t = parent.predicate("fhir:"+name,index > -1);
5811    }
5812    composeBackboneElement(t, "detail", name, element, index);
5813    if (element.hasSequenceElement()) {
5814      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
5815    }
5816    for (int i = 0; i < element.getTraceNumber().size(); i++) {
5817      composeIdentifier(t, "DetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
5818    }
5819    if (element.hasRevenue()) {
5820      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
5821    }
5822    if (element.hasCategory()) {
5823      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
5824    }
5825    if (element.hasProductOrService()) {
5826      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
5827    }
5828    if (element.hasProductOrServiceEnd()) {
5829      composeCodeableConcept(t, "DetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
5830    }
5831    for (int i = 0; i < element.getModifier().size(); i++) {
5832      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
5833    }
5834    for (int i = 0; i < element.getProgramCode().size(); i++) {
5835      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
5836    }
5837    if (element.hasPatientPaid()) {
5838      composeMoney(t, "DetailComponent", "patientPaid", element.getPatientPaid(), -1);
5839    }
5840    if (element.hasQuantity()) {
5841      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
5842    }
5843    if (element.hasUnitPrice()) {
5844      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
5845    }
5846    if (element.hasFactorElement()) {
5847      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
5848    }
5849    if (element.hasTax()) {
5850      composeMoney(t, "DetailComponent", "tax", element.getTax(), -1);
5851    }
5852    if (element.hasNet()) {
5853      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
5854    }
5855    for (int i = 0; i < element.getUdi().size(); i++) {
5856      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
5857    }
5858    for (int i = 0; i < element.getSubDetail().size(); i++) {
5859      composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
5860    }
5861  }
5862
5863  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
5864    if (element == null) 
5865      return;
5866    Complex t;
5867    if (Utilities.noString(parentType))
5868      t = parent;
5869    else {
5870      t = parent.predicate("fhir:"+name,index > -1);
5871    }
5872    composeBackboneElement(t, "subDetail", name, element, index);
5873    if (element.hasSequenceElement()) {
5874      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
5875    }
5876    for (int i = 0; i < element.getTraceNumber().size(); i++) {
5877      composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
5878    }
5879    if (element.hasRevenue()) {
5880      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
5881    }
5882    if (element.hasCategory()) {
5883      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
5884    }
5885    if (element.hasProductOrService()) {
5886      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
5887    }
5888    if (element.hasProductOrServiceEnd()) {
5889      composeCodeableConcept(t, "SubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
5890    }
5891    for (int i = 0; i < element.getModifier().size(); i++) {
5892      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
5893    }
5894    for (int i = 0; i < element.getProgramCode().size(); i++) {
5895      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
5896    }
5897    if (element.hasPatientPaid()) {
5898      composeMoney(t, "SubDetailComponent", "patientPaid", element.getPatientPaid(), -1);
5899    }
5900    if (element.hasQuantity()) {
5901      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
5902    }
5903    if (element.hasUnitPrice()) {
5904      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5905    }
5906    if (element.hasFactorElement()) {
5907      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
5908    }
5909    if (element.hasTax()) {
5910      composeMoney(t, "SubDetailComponent", "tax", element.getTax(), -1);
5911    }
5912    if (element.hasNet()) {
5913      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
5914    }
5915    for (int i = 0; i < element.getUdi().size(); i++) {
5916      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
5917    }
5918  }
5919
5920  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
5921    if (element == null) 
5922      return;
5923    Complex t;
5924    if (Utilities.noString(parentType))
5925      t = parent;
5926    else {
5927      t = parent.predicate("fhir:"+name,index > -1);
5928    }
5929    composeDomainResource(t, "ClaimResponse", name, element, index);
5930    for (int i = 0; i < element.getIdentifier().size(); i++) {
5931      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
5932    }
5933    for (int i = 0; i < element.getTraceNumber().size(); i++) {
5934      composeIdentifier(t, "ClaimResponse", "traceNumber", element.getTraceNumber().get(i), i);
5935    }
5936    if (element.hasStatusElement()) {
5937      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
5938    }
5939    if (element.hasType()) {
5940      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
5941    }
5942    if (element.hasSubType()) {
5943      composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1);
5944    }
5945    if (element.hasUseElement()) {
5946      composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1);
5947    }
5948    if (element.hasPatient()) {
5949      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
5950    }
5951    if (element.hasCreatedElement()) {
5952      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
5953    }
5954    if (element.hasInsurer()) {
5955      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
5956    }
5957    if (element.hasRequestor()) {
5958      composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1);
5959    }
5960    if (element.hasRequest()) {
5961      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
5962    }
5963    if (element.hasOutcomeElement()) {
5964      composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1);
5965    }
5966    if (element.hasDecision()) {
5967      composeCodeableConcept(t, "ClaimResponse", "decision", element.getDecision(), -1);
5968    }
5969    if (element.hasDispositionElement()) {
5970      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
5971    }
5972    if (element.hasPreAuthRefElement()) {
5973      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
5974    }
5975    if (element.hasPreAuthPeriod()) {
5976      composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1);
5977    }
5978    for (int i = 0; i < element.getEvent().size(); i++) {
5979      composeClaimResponseEventComponent(t, "ClaimResponse", "event", element.getEvent().get(i), i);
5980    }
5981    if (element.hasPayeeType()) {
5982      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
5983    }
5984    for (int i = 0; i < element.getEncounter().size(); i++) {
5985      composeReference(t, "ClaimResponse", "encounter", element.getEncounter().get(i), i);
5986    }
5987    if (element.hasDiagnosisRelatedGroup()) {
5988      composeCodeableConcept(t, "ClaimResponse", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1);
5989    }
5990    for (int i = 0; i < element.getItem().size(); i++) {
5991      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
5992    }
5993    for (int i = 0; i < element.getAddItem().size(); i++) {
5994      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
5995    }
5996    for (int i = 0; i < element.getAdjudication().size(); i++) {
5997      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
5998    }
5999    for (int i = 0; i < element.getTotal().size(); i++) {
6000      composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i);
6001    }
6002    if (element.hasPayment()) {
6003      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
6004    }
6005    if (element.hasFundsReserve()) {
6006      composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1);
6007    }
6008    if (element.hasFormCode()) {
6009      composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1);
6010    }
6011    if (element.hasForm()) {
6012      composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1);
6013    }
6014    for (int i = 0; i < element.getProcessNote().size(); i++) {
6015      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
6016    }
6017    for (int i = 0; i < element.getCommunicationRequest().size(); i++) {
6018      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
6019    }
6020    for (int i = 0; i < element.getInsurance().size(); i++) {
6021      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
6022    }
6023    for (int i = 0; i < element.getError().size(); i++) {
6024      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
6025    }
6026  }
6027
6028  protected void composeClaimResponseEventComponent(Complex parent, String parentType, String name, ClaimResponse.ClaimResponseEventComponent element, int index) {
6029    if (element == null) 
6030      return;
6031    Complex t;
6032    if (Utilities.noString(parentType))
6033      t = parent;
6034    else {
6035      t = parent.predicate("fhir:"+name,index > -1);
6036    }
6037    composeBackboneElement(t, "event", name, element, index);
6038    if (element.hasType()) {
6039      composeCodeableConcept(t, "ClaimResponseEventComponent", "type", element.getType(), -1);
6040    }
6041    if (element.hasWhen()) {
6042      composeType(t, "ClaimResponseEventComponent", "when", element.getWhen(), -1);
6043    }
6044  }
6045
6046  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
6047    if (element == null) 
6048      return;
6049    Complex t;
6050    if (Utilities.noString(parentType))
6051      t = parent;
6052    else {
6053      t = parent.predicate("fhir:"+name,index > -1);
6054    }
6055    composeBackboneElement(t, "item", name, element, index);
6056    if (element.hasItemSequenceElement()) {
6057      composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1);
6058    }
6059    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6060      composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
6061    }
6062    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6063      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
6064    }
6065    if (element.hasReviewOutcome()) {
6066      composeClaimResponseReviewOutcomeComponent(t, "ItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6067    }
6068    for (int i = 0; i < element.getAdjudication().size(); i++) {
6069      composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
6070    }
6071    for (int i = 0; i < element.getDetail().size(); i++) {
6072      composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
6073    }
6074  }
6075
6076  protected void composeClaimResponseReviewOutcomeComponent(Complex parent, String parentType, String name, ClaimResponse.ReviewOutcomeComponent element, int index) {
6077    if (element == null) 
6078      return;
6079    Complex t;
6080    if (Utilities.noString(parentType))
6081      t = parent;
6082    else {
6083      t = parent.predicate("fhir:"+name,index > -1);
6084    }
6085    composeBackboneElement(t, "reviewOutcome", name, element, index);
6086    if (element.hasDecision()) {
6087      composeCodeableConcept(t, "ReviewOutcomeComponent", "decision", element.getDecision(), -1);
6088    }
6089    for (int i = 0; i < element.getReason().size(); i++) {
6090      composeCodeableConcept(t, "ReviewOutcomeComponent", "reason", element.getReason().get(i), i);
6091    }
6092    if (element.hasPreAuthRefElement()) {
6093      composeString(t, "ReviewOutcomeComponent", "preAuthRef", element.getPreAuthRefElement(), -1);
6094    }
6095    if (element.hasPreAuthPeriod()) {
6096      composePeriod(t, "ReviewOutcomeComponent", "preAuthPeriod", element.getPreAuthPeriod(), -1);
6097    }
6098  }
6099
6100  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
6101    if (element == null) 
6102      return;
6103    Complex t;
6104    if (Utilities.noString(parentType))
6105      t = parent;
6106    else {
6107      t = parent.predicate("fhir:"+name,index > -1);
6108    }
6109    composeBackboneElement(t, "adjudication", name, element, index);
6110    if (element.hasCategory()) {
6111      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
6112    }
6113    if (element.hasReason()) {
6114      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
6115    }
6116    if (element.hasAmount()) {
6117      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
6118    }
6119    if (element.hasQuantity()) {
6120      composeQuantity(t, "AdjudicationComponent", "quantity", element.getQuantity(), -1);
6121    }
6122  }
6123
6124  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) {
6125    if (element == null) 
6126      return;
6127    Complex t;
6128    if (Utilities.noString(parentType))
6129      t = parent;
6130    else {
6131      t = parent.predicate("fhir:"+name,index > -1);
6132    }
6133    composeBackboneElement(t, "detail", name, element, index);
6134    if (element.hasDetailSequenceElement()) {
6135      composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1);
6136    }
6137    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6138      composeIdentifier(t, "ItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
6139    }
6140    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6141      composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
6142    }
6143    if (element.hasReviewOutcome()) {
6144      composeClaimResponseReviewOutcomeComponent(t, "ItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6145    }
6146    for (int i = 0; i < element.getAdjudication().size(); i++) {
6147      composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
6148    }
6149    for (int i = 0; i < element.getSubDetail().size(); i++) {
6150      composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
6151    }
6152  }
6153
6154  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
6155    if (element == null) 
6156      return;
6157    Complex t;
6158    if (Utilities.noString(parentType))
6159      t = parent;
6160    else {
6161      t = parent.predicate("fhir:"+name,index > -1);
6162    }
6163    composeBackboneElement(t, "subDetail", name, element, index);
6164    if (element.hasSubDetailSequenceElement()) {
6165      composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
6166    }
6167    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6168      composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
6169    }
6170    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6171      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
6172    }
6173    if (element.hasReviewOutcome()) {
6174      composeClaimResponseReviewOutcomeComponent(t, "SubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6175    }
6176    for (int i = 0; i < element.getAdjudication().size(); i++) {
6177      composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
6178    }
6179  }
6180
6181  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
6182    if (element == null) 
6183      return;
6184    Complex t;
6185    if (Utilities.noString(parentType))
6186      t = parent;
6187    else {
6188      t = parent.predicate("fhir:"+name,index > -1);
6189    }
6190    composeBackboneElement(t, "addItem", name, element, index);
6191    for (int i = 0; i < element.getItemSequence().size(); i++) {
6192      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
6193    }
6194    for (int i = 0; i < element.getDetailSequence().size(); i++) {
6195      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
6196    }
6197    for (int i = 0; i < element.getSubdetailSequence().size(); i++) {
6198      composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i);
6199    }
6200    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6201      composeIdentifier(t, "AddedItemComponent", "traceNumber", element.getTraceNumber().get(i), i);
6202    }
6203    for (int i = 0; i < element.getProvider().size(); i++) {
6204      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
6205    }
6206    if (element.hasRevenue()) {
6207      composeCodeableConcept(t, "AddedItemComponent", "revenue", element.getRevenue(), -1);
6208    }
6209    if (element.hasProductOrService()) {
6210      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
6211    }
6212    if (element.hasProductOrServiceEnd()) {
6213      composeCodeableConcept(t, "AddedItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
6214    }
6215    for (int i = 0; i < element.getRequest().size(); i++) {
6216      composeReference(t, "AddedItemComponent", "request", element.getRequest().get(i), i);
6217    }
6218    for (int i = 0; i < element.getModifier().size(); i++) {
6219      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
6220    }
6221    for (int i = 0; i < element.getProgramCode().size(); i++) {
6222      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
6223    }
6224    if (element.hasServiced()) {
6225      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
6226    }
6227    if (element.hasLocation()) {
6228      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
6229    }
6230    if (element.hasQuantity()) {
6231      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
6232    }
6233    if (element.hasUnitPrice()) {
6234      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
6235    }
6236    if (element.hasFactorElement()) {
6237      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
6238    }
6239    if (element.hasTax()) {
6240      composeMoney(t, "AddedItemComponent", "tax", element.getTax(), -1);
6241    }
6242    if (element.hasNet()) {
6243      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
6244    }
6245    for (int i = 0; i < element.getBodySite().size(); i++) {
6246      composeClaimResponseBodySiteComponent(t, "AddedItemComponent", "bodySite", element.getBodySite().get(i), i);
6247    }
6248    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6249      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
6250    }
6251    if (element.hasReviewOutcome()) {
6252      composeClaimResponseReviewOutcomeComponent(t, "AddedItemComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6253    }
6254    for (int i = 0; i < element.getAdjudication().size(); i++) {
6255      composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
6256    }
6257    for (int i = 0; i < element.getDetail().size(); i++) {
6258      composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
6259    }
6260  }
6261
6262  protected void composeClaimResponseBodySiteComponent(Complex parent, String parentType, String name, ClaimResponse.BodySiteComponent element, int index) {
6263    if (element == null) 
6264      return;
6265    Complex t;
6266    if (Utilities.noString(parentType))
6267      t = parent;
6268    else {
6269      t = parent.predicate("fhir:"+name,index > -1);
6270    }
6271    composeBackboneElement(t, "bodySite", name, element, index);
6272    for (int i = 0; i < element.getSite().size(); i++) {
6273      composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i);
6274    }
6275    for (int i = 0; i < element.getSubSite().size(); i++) {
6276      composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i);
6277    }
6278  }
6279
6280  protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) {
6281    if (element == null) 
6282      return;
6283    Complex t;
6284    if (Utilities.noString(parentType))
6285      t = parent;
6286    else {
6287      t = parent.predicate("fhir:"+name,index > -1);
6288    }
6289    composeBackboneElement(t, "detail", name, element, index);
6290    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6291      composeIdentifier(t, "AddedItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
6292    }
6293    if (element.hasRevenue()) {
6294      composeCodeableConcept(t, "AddedItemDetailComponent", "revenue", element.getRevenue(), -1);
6295    }
6296    if (element.hasProductOrService()) {
6297      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
6298    }
6299    if (element.hasProductOrServiceEnd()) {
6300      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
6301    }
6302    for (int i = 0; i < element.getModifier().size(); i++) {
6303      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
6304    }
6305    if (element.hasQuantity()) {
6306      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
6307    }
6308    if (element.hasUnitPrice()) {
6309      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
6310    }
6311    if (element.hasFactorElement()) {
6312      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
6313    }
6314    if (element.hasTax()) {
6315      composeMoney(t, "AddedItemDetailComponent", "tax", element.getTax(), -1);
6316    }
6317    if (element.hasNet()) {
6318      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
6319    }
6320    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6321      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
6322    }
6323    if (element.hasReviewOutcome()) {
6324      composeClaimResponseReviewOutcomeComponent(t, "AddedItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6325    }
6326    for (int i = 0; i < element.getAdjudication().size(); i++) {
6327      composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
6328    }
6329    for (int i = 0; i < element.getSubDetail().size(); i++) {
6330      composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
6331    }
6332  }
6333
6334  protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) {
6335    if (element == null) 
6336      return;
6337    Complex t;
6338    if (Utilities.noString(parentType))
6339      t = parent;
6340    else {
6341      t = parent.predicate("fhir:"+name,index > -1);
6342    }
6343    composeBackboneElement(t, "subDetail", name, element, index);
6344    for (int i = 0; i < element.getTraceNumber().size(); i++) {
6345      composeIdentifier(t, "AddedItemSubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i);
6346    }
6347    if (element.hasRevenue()) {
6348      composeCodeableConcept(t, "AddedItemSubDetailComponent", "revenue", element.getRevenue(), -1);
6349    }
6350    if (element.hasProductOrService()) {
6351      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1);
6352    }
6353    if (element.hasProductOrServiceEnd()) {
6354      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1);
6355    }
6356    for (int i = 0; i < element.getModifier().size(); i++) {
6357      composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i);
6358    }
6359    if (element.hasQuantity()) {
6360      composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1);
6361    }
6362    if (element.hasUnitPrice()) {
6363      composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
6364    }
6365    if (element.hasFactorElement()) {
6366      composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1);
6367    }
6368    if (element.hasTax()) {
6369      composeMoney(t, "AddedItemSubDetailComponent", "tax", element.getTax(), -1);
6370    }
6371    if (element.hasNet()) {
6372      composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1);
6373    }
6374    for (int i = 0; i < element.getNoteNumber().size(); i++) {
6375      composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
6376    }
6377    if (element.hasReviewOutcome()) {
6378      composeClaimResponseReviewOutcomeComponent(t, "AddedItemSubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1);
6379    }
6380    for (int i = 0; i < element.getAdjudication().size(); i++) {
6381      composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
6382    }
6383  }
6384
6385  protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) {
6386    if (element == null) 
6387      return;
6388    Complex t;
6389    if (Utilities.noString(parentType))
6390      t = parent;
6391    else {
6392      t = parent.predicate("fhir:"+name,index > -1);
6393    }
6394    composeBackboneElement(t, "total", name, element, index);
6395    if (element.hasCategory()) {
6396      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
6397    }
6398    if (element.hasAmount()) {
6399      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
6400    }
6401  }
6402
6403  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) {
6404    if (element == null) 
6405      return;
6406    Complex t;
6407    if (Utilities.noString(parentType))
6408      t = parent;
6409    else {
6410      t = parent.predicate("fhir:"+name,index > -1);
6411    }
6412    composeBackboneElement(t, "payment", name, element, index);
6413    if (element.hasType()) {
6414      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
6415    }
6416    if (element.hasAdjustment()) {
6417      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
6418    }
6419    if (element.hasAdjustmentReason()) {
6420      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
6421    }
6422    if (element.hasDateElement()) {
6423      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
6424    }
6425    if (element.hasAmount()) {
6426      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
6427    }
6428    if (element.hasIdentifier()) {
6429      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
6430    }
6431  }
6432
6433  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
6434    if (element == null) 
6435      return;
6436    Complex t;
6437    if (Utilities.noString(parentType))
6438      t = parent;
6439    else {
6440      t = parent.predicate("fhir:"+name,index > -1);
6441    }
6442    composeBackboneElement(t, "processNote", name, element, index);
6443    if (element.hasNumberElement()) {
6444      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
6445    }
6446    if (element.hasType()) {
6447      composeCodeableConcept(t, "NoteComponent", "type", element.getType(), -1);
6448    }
6449    if (element.hasTextElement()) {
6450      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
6451    }
6452    if (element.hasLanguage()) {
6453      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
6454    }
6455  }
6456
6457  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
6458    if (element == null) 
6459      return;
6460    Complex t;
6461    if (Utilities.noString(parentType))
6462      t = parent;
6463    else {
6464      t = parent.predicate("fhir:"+name,index > -1);
6465    }
6466    composeBackboneElement(t, "insurance", name, element, index);
6467    if (element.hasSequenceElement()) {
6468      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
6469    }
6470    if (element.hasFocalElement()) {
6471      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
6472    }
6473    if (element.hasCoverage()) {
6474      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
6475    }
6476    if (element.hasBusinessArrangementElement()) {
6477      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
6478    }
6479    if (element.hasClaimResponse()) {
6480      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
6481    }
6482  }
6483
6484  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
6485    if (element == null) 
6486      return;
6487    Complex t;
6488    if (Utilities.noString(parentType))
6489      t = parent;
6490    else {
6491      t = parent.predicate("fhir:"+name,index > -1);
6492    }
6493    composeBackboneElement(t, "error", name, element, index);
6494    if (element.hasItemSequenceElement()) {
6495      composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1);
6496    }
6497    if (element.hasDetailSequenceElement()) {
6498      composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1);
6499    }
6500    if (element.hasSubDetailSequenceElement()) {
6501      composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
6502    }
6503    if (element.hasCode()) {
6504      composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1);
6505    }
6506    for (int i = 0; i < element.getExpression().size(); i++) {
6507      composeString(t, "ErrorComponent", "expression", element.getExpression().get(i), i);
6508    }
6509  }
6510
6511  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) {
6512    if (element == null) 
6513      return;
6514    Complex t;
6515    if (Utilities.noString(parentType))
6516      t = parent;
6517    else {
6518      t = parent.predicate("fhir:"+name,index > -1);
6519    }
6520    composeDomainResource(t, "ClinicalImpression", name, element, index);
6521    for (int i = 0; i < element.getIdentifier().size(); i++) {
6522      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
6523    }
6524    if (element.hasStatusElement()) {
6525      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
6526    }
6527    if (element.hasStatusReason()) {
6528      composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1);
6529    }
6530    if (element.hasDescriptionElement()) {
6531      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
6532    }
6533    if (element.hasSubject()) {
6534      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
6535    }
6536    if (element.hasEncounter()) {
6537      composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1);
6538    }
6539    if (element.hasEffective()) {
6540      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
6541    }
6542    if (element.hasDateElement()) {
6543      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
6544    }
6545    if (element.hasPerformer()) {
6546      composeReference(t, "ClinicalImpression", "performer", element.getPerformer(), -1);
6547    }
6548    if (element.hasPrevious()) {
6549      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
6550    }
6551    for (int i = 0; i < element.getProblem().size(); i++) {
6552      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
6553    }
6554    if (element.hasChangePattern()) {
6555      composeCodeableConcept(t, "ClinicalImpression", "changePattern", element.getChangePattern(), -1);
6556    }
6557    for (int i = 0; i < element.getProtocol().size(); i++) {
6558      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
6559    }
6560    if (element.hasSummaryElement()) {
6561      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
6562    }
6563    for (int i = 0; i < element.getFinding().size(); i++) {
6564      composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
6565    }
6566    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) {
6567      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
6568    }
6569    for (int i = 0; i < element.getPrognosisReference().size(); i++) {
6570      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
6571    }
6572    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
6573      composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i);
6574    }
6575    for (int i = 0; i < element.getNote().size(); i++) {
6576      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
6577    }
6578  }
6579
6580  protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
6581    if (element == null) 
6582      return;
6583    Complex t;
6584    if (Utilities.noString(parentType))
6585      t = parent;
6586    else {
6587      t = parent.predicate("fhir:"+name,index > -1);
6588    }
6589    composeBackboneElement(t, "finding", name, element, index);
6590    if (element.hasItem()) {
6591      composeCodeableReference(t, "ClinicalImpressionFindingComponent", "item", element.getItem(), -1);
6592    }
6593    if (element.hasBasisElement()) {
6594      composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1);
6595    }
6596  }
6597
6598  protected void composeClinicalUseDefinition(Complex parent, String parentType, String name, ClinicalUseDefinition element, int index) {
6599    if (element == null) 
6600      return;
6601    Complex t;
6602    if (Utilities.noString(parentType))
6603      t = parent;
6604    else {
6605      t = parent.predicate("fhir:"+name,index > -1);
6606    }
6607    composeDomainResource(t, "ClinicalUseDefinition", name, element, index);
6608    for (int i = 0; i < element.getIdentifier().size(); i++) {
6609      composeIdentifier(t, "ClinicalUseDefinition", "identifier", element.getIdentifier().get(i), i);
6610    }
6611    if (element.hasTypeElement()) {
6612      composeEnum(t, "ClinicalUseDefinition", "type", element.getTypeElement(), -1);
6613    }
6614    for (int i = 0; i < element.getCategory().size(); i++) {
6615      composeCodeableConcept(t, "ClinicalUseDefinition", "category", element.getCategory().get(i), i);
6616    }
6617    for (int i = 0; i < element.getSubject().size(); i++) {
6618      composeReference(t, "ClinicalUseDefinition", "subject", element.getSubject().get(i), i);
6619    }
6620    if (element.hasStatus()) {
6621      composeCodeableConcept(t, "ClinicalUseDefinition", "status", element.getStatus(), -1);
6622    }
6623    if (element.hasContraindication()) {
6624      composeClinicalUseDefinitionContraindicationComponent(t, "ClinicalUseDefinition", "contraindication", element.getContraindication(), -1);
6625    }
6626    if (element.hasIndication()) {
6627      composeClinicalUseDefinitionIndicationComponent(t, "ClinicalUseDefinition", "indication", element.getIndication(), -1);
6628    }
6629    if (element.hasInteraction()) {
6630      composeClinicalUseDefinitionInteractionComponent(t, "ClinicalUseDefinition", "interaction", element.getInteraction(), -1);
6631    }
6632    for (int i = 0; i < element.getPopulation().size(); i++) {
6633      composeReference(t, "ClinicalUseDefinition", "population", element.getPopulation().get(i), i);
6634    }
6635    for (int i = 0; i < element.getLibrary().size(); i++) {
6636      composeCanonical(t, "ClinicalUseDefinition", "library", element.getLibrary().get(i), i);
6637    }
6638    if (element.hasUndesirableEffect()) {
6639      composeClinicalUseDefinitionUndesirableEffectComponent(t, "ClinicalUseDefinition", "undesirableEffect", element.getUndesirableEffect(), -1);
6640    }
6641    if (element.hasWarning()) {
6642      composeClinicalUseDefinitionWarningComponent(t, "ClinicalUseDefinition", "warning", element.getWarning(), -1);
6643    }
6644  }
6645
6646  protected void composeClinicalUseDefinitionContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent element, int index) {
6647    if (element == null) 
6648      return;
6649    Complex t;
6650    if (Utilities.noString(parentType))
6651      t = parent;
6652    else {
6653      t = parent.predicate("fhir:"+name,index > -1);
6654    }
6655    composeBackboneElement(t, "contraindication", name, element, index);
6656    if (element.hasDiseaseSymptomProcedure()) {
6657      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
6658    }
6659    if (element.hasDiseaseStatus()) {
6660      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
6661    }
6662    for (int i = 0; i < element.getComorbidity().size(); i++) {
6663      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i);
6664    }
6665    for (int i = 0; i < element.getIndication().size(); i++) {
6666      composeReference(t, "ClinicalUseDefinitionContraindicationComponent", "indication", element.getIndication().get(i), i);
6667    }
6668    if (element.hasApplicability()) {
6669      composeExpression(t, "ClinicalUseDefinitionContraindicationComponent", "applicability", element.getApplicability(), -1);
6670    }
6671    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
6672      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
6673    }
6674  }
6675
6676  protected void composeClinicalUseDefinitionContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent element, int index) {
6677    if (element == null) 
6678      return;
6679    Complex t;
6680    if (Utilities.noString(parentType))
6681      t = parent;
6682    else {
6683      t = parent.predicate("fhir:"+name,index > -1);
6684    }
6685    composeBackboneElement(t, "otherTherapy", name, element, index);
6686    if (element.hasRelationshipType()) {
6687      composeCodeableConcept(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "relationshipType", element.getRelationshipType(), -1);
6688    }
6689    if (element.hasTreatment()) {
6690      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "treatment", element.getTreatment(), -1);
6691    }
6692  }
6693
6694  protected void composeClinicalUseDefinitionIndicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent element, int index) {
6695    if (element == null) 
6696      return;
6697    Complex t;
6698    if (Utilities.noString(parentType))
6699      t = parent;
6700    else {
6701      t = parent.predicate("fhir:"+name,index > -1);
6702    }
6703    composeBackboneElement(t, "indication", name, element, index);
6704    if (element.hasDiseaseSymptomProcedure()) {
6705      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
6706    }
6707    if (element.hasDiseaseStatus()) {
6708      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
6709    }
6710    for (int i = 0; i < element.getComorbidity().size(); i++) {
6711      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "comorbidity", element.getComorbidity().get(i), i);
6712    }
6713    if (element.hasIntendedEffect()) {
6714      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1);
6715    }
6716    if (element.hasDuration()) {
6717      composeType(t, "ClinicalUseDefinitionIndicationComponent", "duration", element.getDuration(), -1);
6718    }
6719    for (int i = 0; i < element.getUndesirableEffect().size(); i++) {
6720      composeReference(t, "ClinicalUseDefinitionIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i);
6721    }
6722    if (element.hasApplicability()) {
6723      composeExpression(t, "ClinicalUseDefinitionIndicationComponent", "applicability", element.getApplicability(), -1);
6724    }
6725    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
6726      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
6727    }
6728  }
6729
6730  protected void composeClinicalUseDefinitionInteractionComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent element, int index) {
6731    if (element == null) 
6732      return;
6733    Complex t;
6734    if (Utilities.noString(parentType))
6735      t = parent;
6736    else {
6737      t = parent.predicate("fhir:"+name,index > -1);
6738    }
6739    composeBackboneElement(t, "interaction", name, element, index);
6740    for (int i = 0; i < element.getInteractant().size(); i++) {
6741      composeClinicalUseDefinitionInteractionInteractantComponent(t, "ClinicalUseDefinitionInteractionComponent", "interactant", element.getInteractant().get(i), i);
6742    }
6743    if (element.hasType()) {
6744      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "type", element.getType(), -1);
6745    }
6746    if (element.hasEffect()) {
6747      composeCodeableReference(t, "ClinicalUseDefinitionInteractionComponent", "effect", element.getEffect(), -1);
6748    }
6749    if (element.hasIncidence()) {
6750      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "incidence", element.getIncidence(), -1);
6751    }
6752    for (int i = 0; i < element.getManagement().size(); i++) {
6753      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "management", element.getManagement().get(i), i);
6754    }
6755  }
6756
6757  protected void composeClinicalUseDefinitionInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent element, int index) {
6758    if (element == null) 
6759      return;
6760    Complex t;
6761    if (Utilities.noString(parentType))
6762      t = parent;
6763    else {
6764      t = parent.predicate("fhir:"+name,index > -1);
6765    }
6766    composeBackboneElement(t, "interactant", name, element, index);
6767    if (element.hasItem()) {
6768      composeType(t, "ClinicalUseDefinitionInteractionInteractantComponent", "item", element.getItem(), -1);
6769    }
6770  }
6771
6772  protected void composeClinicalUseDefinitionUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent element, int index) {
6773    if (element == null) 
6774      return;
6775    Complex t;
6776    if (Utilities.noString(parentType))
6777      t = parent;
6778    else {
6779      t = parent.predicate("fhir:"+name,index > -1);
6780    }
6781    composeBackboneElement(t, "undesirableEffect", name, element, index);
6782    if (element.hasSymptomConditionEffect()) {
6783      composeCodeableReference(t, "ClinicalUseDefinitionUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1);
6784    }
6785    if (element.hasClassification()) {
6786      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "classification", element.getClassification(), -1);
6787    }
6788    if (element.hasFrequencyOfOccurrence()) {
6789      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1);
6790    }
6791  }
6792
6793  protected void composeClinicalUseDefinitionWarningComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent element, int index) {
6794    if (element == null) 
6795      return;
6796    Complex t;
6797    if (Utilities.noString(parentType))
6798      t = parent;
6799    else {
6800      t = parent.predicate("fhir:"+name,index > -1);
6801    }
6802    composeBackboneElement(t, "warning", name, element, index);
6803    if (element.hasDescriptionElement()) {
6804      composeMarkdown(t, "ClinicalUseDefinitionWarningComponent", "description", element.getDescriptionElement(), -1);
6805    }
6806    if (element.hasCode()) {
6807      composeCodeableConcept(t, "ClinicalUseDefinitionWarningComponent", "code", element.getCode(), -1);
6808    }
6809  }
6810
6811  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) {
6812    if (element == null) 
6813      return;
6814    Complex t;
6815    if (Utilities.noString(parentType))
6816      t = parent;
6817    else {
6818      t = parent.predicate("fhir:"+name,index > -1);
6819    }
6820    composeMetadataResource(t, "CodeSystem", name, element, index);
6821    if (element.hasUrlElement()) {
6822      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
6823    }
6824    for (int i = 0; i < element.getIdentifier().size(); i++) {
6825      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i);
6826    }
6827    if (element.hasVersionElement()) {
6828      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
6829    }
6830    if (element.hasVersionAlgorithm()) {
6831      composeType(t, "CodeSystem", "versionAlgorithm", element.getVersionAlgorithm(), -1);
6832    }
6833    if (element.hasNameElement()) {
6834      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
6835    }
6836    if (element.hasTitleElement()) {
6837      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
6838    }
6839    if (element.hasStatusElement()) {
6840      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
6841    }
6842    if (element.hasExperimentalElement()) {
6843      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
6844    }
6845    if (element.hasDateElement()) {
6846      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
6847    }
6848    if (element.hasPublisherElement()) {
6849      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
6850    }
6851    for (int i = 0; i < element.getContact().size(); i++) {
6852      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
6853    }
6854    if (element.hasDescriptionElement()) {
6855      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
6856    }
6857    for (int i = 0; i < element.getUseContext().size(); i++) {
6858      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
6859    }
6860    for (int i = 0; i < element.getJurisdiction().size(); i++) {
6861      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
6862    }
6863    if (element.hasPurposeElement()) {
6864      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
6865    }
6866    if (element.hasCopyrightElement()) {
6867      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
6868    }
6869    if (element.hasCopyrightLabelElement()) {
6870      composeString(t, "CodeSystem", "copyrightLabel", element.getCopyrightLabelElement(), -1);
6871    }
6872    if (element.hasApprovalDateElement()) {
6873      composeDate(t, "CodeSystem", "approvalDate", element.getApprovalDateElement(), -1);
6874    }
6875    if (element.hasLastReviewDateElement()) {
6876      composeDate(t, "CodeSystem", "lastReviewDate", element.getLastReviewDateElement(), -1);
6877    }
6878    if (element.hasEffectivePeriod()) {
6879      composePeriod(t, "CodeSystem", "effectivePeriod", element.getEffectivePeriod(), -1);
6880    }
6881    for (int i = 0; i < element.getTopic().size(); i++) {
6882      composeCodeableConcept(t, "CodeSystem", "topic", element.getTopic().get(i), i);
6883    }
6884    for (int i = 0; i < element.getAuthor().size(); i++) {
6885      composeContactDetail(t, "CodeSystem", "author", element.getAuthor().get(i), i);
6886    }
6887    for (int i = 0; i < element.getEditor().size(); i++) {
6888      composeContactDetail(t, "CodeSystem", "editor", element.getEditor().get(i), i);
6889    }
6890    for (int i = 0; i < element.getReviewer().size(); i++) {
6891      composeContactDetail(t, "CodeSystem", "reviewer", element.getReviewer().get(i), i);
6892    }
6893    for (int i = 0; i < element.getEndorser().size(); i++) {
6894      composeContactDetail(t, "CodeSystem", "endorser", element.getEndorser().get(i), i);
6895    }
6896    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
6897      composeRelatedArtifact(t, "CodeSystem", "relatedArtifact", element.getRelatedArtifact().get(i), i);
6898    }
6899    if (element.hasCaseSensitiveElement()) {
6900      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
6901    }
6902    if (element.hasValueSetElement()) {
6903      composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
6904    }
6905    if (element.hasHierarchyMeaningElement()) {
6906      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
6907    }
6908    if (element.hasCompositionalElement()) {
6909      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
6910    }
6911    if (element.hasVersionNeededElement()) {
6912      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
6913    }
6914    if (element.hasContentElement()) {
6915      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
6916    }
6917    if (element.hasSupplementsElement()) {
6918      composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1);
6919    }
6920    if (element.hasCountElement()) {
6921      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
6922    }
6923    for (int i = 0; i < element.getFilter().size(); i++) {
6924      composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
6925    }
6926    for (int i = 0; i < element.getProperty().size(); i++) {
6927      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
6928    }
6929    for (int i = 0; i < element.getConcept().size(); i++) {
6930      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
6931    }
6932  }
6933
6934  protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) {
6935    if (element == null) 
6936      return;
6937    Complex t;
6938    if (Utilities.noString(parentType))
6939      t = parent;
6940    else {
6941      t = parent.predicate("fhir:"+name,index > -1);
6942    }
6943    composeBackboneElement(t, "filter", name, element, index);
6944    if (element.hasCodeElement()) {
6945      composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1);
6946    }
6947    if (element.hasDescriptionElement()) {
6948      composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1);
6949    }
6950    for (int i = 0; i < element.getOperator().size(); i++) {
6951      composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i);
6952    }
6953    if (element.hasValueElement()) {
6954      composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1);
6955    }
6956  }
6957
6958  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
6959    if (element == null) 
6960      return;
6961    Complex t;
6962    if (Utilities.noString(parentType))
6963      t = parent;
6964    else {
6965      t = parent.predicate("fhir:"+name,index > -1);
6966    }
6967    composeBackboneElement(t, "property", name, element, index);
6968    if (element.hasCodeElement()) {
6969      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
6970    }
6971    if (element.hasUriElement()) {
6972      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
6973    }
6974    if (element.hasDescriptionElement()) {
6975      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
6976    }
6977    if (element.hasTypeElement()) {
6978      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
6979    }
6980  }
6981
6982  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
6983    if (element == null) 
6984      return;
6985    Complex t;
6986    if (Utilities.noString(parentType))
6987      t = parent;
6988    else {
6989      t = parent.predicate("fhir:"+name,index > -1);
6990    }
6991    composeBackboneElement(t, "concept", name, element, index);
6992    if (element.hasCodeElement()) {
6993      composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1);
6994    }
6995    if (element.hasDisplayElement()) {
6996      composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1);
6997    }
6998    if (element.hasDefinitionElement()) {
6999      composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1);
7000    }
7001    for (int i = 0; i < element.getDesignation().size(); i++) {
7002      composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i);
7003    }
7004    for (int i = 0; i < element.getProperty().size(); i++) {
7005      composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i);
7006    }
7007    for (int i = 0; i < element.getConcept().size(); i++) {
7008      composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i);
7009    }
7010  }
7011
7012  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
7013    if (element == null) 
7014      return;
7015    Complex t;
7016    if (Utilities.noString(parentType))
7017      t = parent;
7018    else {
7019      t = parent.predicate("fhir:"+name,index > -1);
7020    }
7021    composeBackboneElement(t, "designation", name, element, index);
7022    if (element.hasLanguageElement()) {
7023      composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1);
7024    }
7025    if (element.hasUse()) {
7026      composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1);
7027    }
7028    for (int i = 0; i < element.getAdditionalUse().size(); i++) {
7029      composeCoding(t, "ConceptDefinitionDesignationComponent", "additionalUse", element.getAdditionalUse().get(i), i);
7030    }
7031    if (element.hasValueElement()) {
7032      composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1);
7033    }
7034  }
7035
7036  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
7037    if (element == null) 
7038      return;
7039    Complex t;
7040    if (Utilities.noString(parentType))
7041      t = parent;
7042    else {
7043      t = parent.predicate("fhir:"+name,index > -1);
7044    }
7045    composeBackboneElement(t, "property", name, element, index);
7046    if (element.hasCodeElement()) {
7047      composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1);
7048    }
7049    if (element.hasValue()) {
7050      composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1);
7051    }
7052  }
7053
7054  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
7055    if (element == null) 
7056      return;
7057    Complex t;
7058    if (Utilities.noString(parentType))
7059      t = parent;
7060    else {
7061      t = parent.predicate("fhir:"+name,index > -1);
7062    }
7063    composeDomainResource(t, "Communication", name, element, index);
7064    for (int i = 0; i < element.getIdentifier().size(); i++) {
7065      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
7066    }
7067    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
7068      composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
7069    }
7070    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
7071      composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i);
7072    }
7073    for (int i = 0; i < element.getBasedOn().size(); i++) {
7074      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
7075    }
7076    for (int i = 0; i < element.getPartOf().size(); i++) {
7077      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
7078    }
7079    for (int i = 0; i < element.getInResponseTo().size(); i++) {
7080      composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i);
7081    }
7082    if (element.hasStatusElement()) {
7083      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
7084    }
7085    if (element.hasStatusReason()) {
7086      composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1);
7087    }
7088    for (int i = 0; i < element.getCategory().size(); i++) {
7089      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
7090    }
7091    if (element.hasPriorityElement()) {
7092      composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1);
7093    }
7094    for (int i = 0; i < element.getMedium().size(); i++) {
7095      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
7096    }
7097    if (element.hasSubject()) {
7098      composeReference(t, "Communication", "subject", element.getSubject(), -1);
7099    }
7100    if (element.hasTopic()) {
7101      composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1);
7102    }
7103    for (int i = 0; i < element.getAbout().size(); i++) {
7104      composeReference(t, "Communication", "about", element.getAbout().get(i), i);
7105    }
7106    if (element.hasEncounter()) {
7107      composeReference(t, "Communication", "encounter", element.getEncounter(), -1);
7108    }
7109    if (element.hasSentElement()) {
7110      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
7111    }
7112    if (element.hasReceivedElement()) {
7113      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
7114    }
7115    for (int i = 0; i < element.getRecipient().size(); i++) {
7116      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
7117    }
7118    if (element.hasSender()) {
7119      composeReference(t, "Communication", "sender", element.getSender(), -1);
7120    }
7121    for (int i = 0; i < element.getReason().size(); i++) {
7122      composeCodeableReference(t, "Communication", "reason", element.getReason().get(i), i);
7123    }
7124    for (int i = 0; i < element.getPayload().size(); i++) {
7125      composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
7126    }
7127    for (int i = 0; i < element.getNote().size(); i++) {
7128      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
7129    }
7130  }
7131
7132  protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
7133    if (element == null) 
7134      return;
7135    Complex t;
7136    if (Utilities.noString(parentType))
7137      t = parent;
7138    else {
7139      t = parent.predicate("fhir:"+name,index > -1);
7140    }
7141    composeBackboneElement(t, "payload", name, element, index);
7142    if (element.hasContent()) {
7143      composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1);
7144    }
7145  }
7146
7147  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
7148    if (element == null) 
7149      return;
7150    Complex t;
7151    if (Utilities.noString(parentType))
7152      t = parent;
7153    else {
7154      t = parent.predicate("fhir:"+name,index > -1);
7155    }
7156    composeDomainResource(t, "CommunicationRequest", name, element, index);
7157    for (int i = 0; i < element.getIdentifier().size(); i++) {
7158      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
7159    }
7160    for (int i = 0; i < element.getBasedOn().size(); i++) {
7161      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
7162    }
7163    for (int i = 0; i < element.getReplaces().size(); i++) {
7164      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
7165    }
7166    if (element.hasGroupIdentifier()) {
7167      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
7168    }
7169    if (element.hasStatusElement()) {
7170      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
7171    }
7172    if (element.hasStatusReason()) {
7173      composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1);
7174    }
7175    if (element.hasIntentElement()) {
7176      composeEnum(t, "CommunicationRequest", "intent", element.getIntentElement(), -1);
7177    }
7178    for (int i = 0; i < element.getCategory().size(); i++) {
7179      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
7180    }
7181    if (element.hasPriorityElement()) {
7182      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
7183    }
7184    if (element.hasDoNotPerformElement()) {
7185      composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
7186    }
7187    for (int i = 0; i < element.getMedium().size(); i++) {
7188      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
7189    }
7190    if (element.hasSubject()) {
7191      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
7192    }
7193    for (int i = 0; i < element.getAbout().size(); i++) {
7194      composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i);
7195    }
7196    if (element.hasEncounter()) {
7197      composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1);
7198    }
7199    for (int i = 0; i < element.getPayload().size(); i++) {
7200      composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
7201    }
7202    if (element.hasOccurrence()) {
7203      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
7204    }
7205    if (element.hasAuthoredOnElement()) {
7206      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
7207    }
7208    if (element.hasRequester()) {
7209      composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1);
7210    }
7211    for (int i = 0; i < element.getRecipient().size(); i++) {
7212      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
7213    }
7214    for (int i = 0; i < element.getInformationProvider().size(); i++) {
7215      composeReference(t, "CommunicationRequest", "informationProvider", element.getInformationProvider().get(i), i);
7216    }
7217    for (int i = 0; i < element.getReason().size(); i++) {
7218      composeCodeableReference(t, "CommunicationRequest", "reason", element.getReason().get(i), i);
7219    }
7220    for (int i = 0; i < element.getNote().size(); i++) {
7221      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
7222    }
7223  }
7224
7225  protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
7226    if (element == null) 
7227      return;
7228    Complex t;
7229    if (Utilities.noString(parentType))
7230      t = parent;
7231    else {
7232      t = parent.predicate("fhir:"+name,index > -1);
7233    }
7234    composeBackboneElement(t, "payload", name, element, index);
7235    if (element.hasContent()) {
7236      composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1);
7237    }
7238  }
7239
7240  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
7241    if (element == null) 
7242      return;
7243    Complex t;
7244    if (Utilities.noString(parentType))
7245      t = parent;
7246    else {
7247      t = parent.predicate("fhir:"+name,index > -1);
7248    }
7249    composeCanonicalResource(t, "CompartmentDefinition", name, element, index);
7250    if (element.hasUrlElement()) {
7251      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
7252    }
7253    if (element.hasVersionElement()) {
7254      composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1);
7255    }
7256    if (element.hasVersionAlgorithm()) {
7257      composeType(t, "CompartmentDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
7258    }
7259    if (element.hasNameElement()) {
7260      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
7261    }
7262    if (element.hasTitleElement()) {
7263      composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1);
7264    }
7265    if (element.hasStatusElement()) {
7266      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
7267    }
7268    if (element.hasExperimentalElement()) {
7269      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
7270    }
7271    if (element.hasDateElement()) {
7272      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
7273    }
7274    if (element.hasPublisherElement()) {
7275      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
7276    }
7277    for (int i = 0; i < element.getContact().size(); i++) {
7278      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
7279    }
7280    if (element.hasDescriptionElement()) {
7281      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
7282    }
7283    for (int i = 0; i < element.getUseContext().size(); i++) {
7284      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
7285    }
7286    if (element.hasPurposeElement()) {
7287      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
7288    }
7289    if (element.hasCodeElement()) {
7290      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
7291    }
7292    if (element.hasSearchElement()) {
7293      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
7294    }
7295    for (int i = 0; i < element.getResource().size(); i++) {
7296      composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
7297    }
7298  }
7299
7300  protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
7301    if (element == null) 
7302      return;
7303    Complex t;
7304    if (Utilities.noString(parentType))
7305      t = parent;
7306    else {
7307      t = parent.predicate("fhir:"+name,index > -1);
7308    }
7309    composeBackboneElement(t, "resource", name, element, index);
7310    if (element.hasCodeElement()) {
7311      composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1);
7312    }
7313    for (int i = 0; i < element.getParam().size(); i++) {
7314      composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i);
7315    }
7316    if (element.hasDocumentationElement()) {
7317      composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1);
7318    }
7319    if (element.hasStartParamElement()) {
7320      composeUri(t, "CompartmentDefinitionResourceComponent", "startParam", element.getStartParamElement(), -1);
7321    }
7322    if (element.hasEndParamElement()) {
7323      composeUri(t, "CompartmentDefinitionResourceComponent", "endParam", element.getEndParamElement(), -1);
7324    }
7325  }
7326
7327  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
7328    if (element == null) 
7329      return;
7330    Complex t;
7331    if (Utilities.noString(parentType))
7332      t = parent;
7333    else {
7334      t = parent.predicate("fhir:"+name,index > -1);
7335    }
7336    composeDomainResource(t, "Composition", name, element, index);
7337    if (element.hasUrlElement()) {
7338      composeUri(t, "Composition", "url", element.getUrlElement(), -1);
7339    }
7340    for (int i = 0; i < element.getIdentifier().size(); i++) {
7341      composeIdentifier(t, "Composition", "identifier", element.getIdentifier().get(i), i);
7342    }
7343    if (element.hasVersionElement()) {
7344      composeString(t, "Composition", "version", element.getVersionElement(), -1);
7345    }
7346    if (element.hasStatusElement()) {
7347      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
7348    }
7349    if (element.hasType()) {
7350      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
7351    }
7352    for (int i = 0; i < element.getCategory().size(); i++) {
7353      composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i);
7354    }
7355    for (int i = 0; i < element.getSubject().size(); i++) {
7356      composeReference(t, "Composition", "subject", element.getSubject().get(i), i);
7357    }
7358    if (element.hasEncounter()) {
7359      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
7360    }
7361    if (element.hasDateElement()) {
7362      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
7363    }
7364    for (int i = 0; i < element.getUseContext().size(); i++) {
7365      composeUsageContext(t, "Composition", "useContext", element.getUseContext().get(i), i);
7366    }
7367    for (int i = 0; i < element.getAuthor().size(); i++) {
7368      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
7369    }
7370    if (element.hasNameElement()) {
7371      composeString(t, "Composition", "name", element.getNameElement(), -1);
7372    }
7373    if (element.hasTitleElement()) {
7374      composeString(t, "Composition", "title", element.getTitleElement(), -1);
7375    }
7376    for (int i = 0; i < element.getNote().size(); i++) {
7377      composeAnnotation(t, "Composition", "note", element.getNote().get(i), i);
7378    }
7379    for (int i = 0; i < element.getAttester().size(); i++) {
7380      composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
7381    }
7382    if (element.hasCustodian()) {
7383      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
7384    }
7385    for (int i = 0; i < element.getRelatesTo().size(); i++) {
7386      composeRelatedArtifact(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
7387    }
7388    for (int i = 0; i < element.getEvent().size(); i++) {
7389      composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
7390    }
7391    for (int i = 0; i < element.getSection().size(); i++) {
7392      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
7393    }
7394  }
7395
7396  protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
7397    if (element == null) 
7398      return;
7399    Complex t;
7400    if (Utilities.noString(parentType))
7401      t = parent;
7402    else {
7403      t = parent.predicate("fhir:"+name,index > -1);
7404    }
7405    composeBackboneElement(t, "attester", name, element, index);
7406    if (element.hasMode()) {
7407      composeCodeableConcept(t, "CompositionAttesterComponent", "mode", element.getMode(), -1);
7408    }
7409    if (element.hasTimeElement()) {
7410      composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1);
7411    }
7412    if (element.hasParty()) {
7413      composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1);
7414    }
7415  }
7416
7417  protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
7418    if (element == null) 
7419      return;
7420    Complex t;
7421    if (Utilities.noString(parentType))
7422      t = parent;
7423    else {
7424      t = parent.predicate("fhir:"+name,index > -1);
7425    }
7426    composeBackboneElement(t, "event", name, element, index);
7427    if (element.hasPeriod()) {
7428      composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1);
7429    }
7430    for (int i = 0; i < element.getDetail().size(); i++) {
7431      composeCodeableReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i);
7432    }
7433  }
7434
7435  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
7436    if (element == null) 
7437      return;
7438    Complex t;
7439    if (Utilities.noString(parentType))
7440      t = parent;
7441    else {
7442      t = parent.predicate("fhir:"+name,index > -1);
7443    }
7444    composeBackboneElement(t, "section", name, element, index);
7445    if (element.hasTitleElement()) {
7446      composeString(t, "SectionComponent", "title", element.getTitleElement(), -1);
7447    }
7448    if (element.hasCode()) {
7449      composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1);
7450    }
7451    for (int i = 0; i < element.getAuthor().size(); i++) {
7452      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
7453    }
7454    if (element.hasFocus()) {
7455      composeReference(t, "SectionComponent", "focus", element.getFocus(), -1);
7456    }
7457    if (element.hasText()) {
7458      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
7459    }
7460    if (element.hasOrderedBy()) {
7461      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
7462    }
7463    for (int i = 0; i < element.getEntry().size(); i++) {
7464      composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i);
7465    }
7466    if (element.hasEmptyReason()) {
7467      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
7468    }
7469    for (int i = 0; i < element.getSection().size(); i++) {
7470      composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
7471    }
7472  }
7473
7474  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
7475    if (element == null) 
7476      return;
7477    Complex t;
7478    if (Utilities.noString(parentType))
7479      t = parent;
7480    else {
7481      t = parent.predicate("fhir:"+name,index > -1);
7482    }
7483    composeMetadataResource(t, "ConceptMap", name, element, index);
7484    if (element.hasUrlElement()) {
7485      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
7486    }
7487    for (int i = 0; i < element.getIdentifier().size(); i++) {
7488      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier().get(i), i);
7489    }
7490    if (element.hasVersionElement()) {
7491      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
7492    }
7493    if (element.hasVersionAlgorithm()) {
7494      composeType(t, "ConceptMap", "versionAlgorithm", element.getVersionAlgorithm(), -1);
7495    }
7496    if (element.hasNameElement()) {
7497      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
7498    }
7499    if (element.hasTitleElement()) {
7500      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
7501    }
7502    if (element.hasStatusElement()) {
7503      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
7504    }
7505    if (element.hasExperimentalElement()) {
7506      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
7507    }
7508    if (element.hasDateElement()) {
7509      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
7510    }
7511    if (element.hasPublisherElement()) {
7512      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
7513    }
7514    for (int i = 0; i < element.getContact().size(); i++) {
7515      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
7516    }
7517    if (element.hasDescriptionElement()) {
7518      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
7519    }
7520    for (int i = 0; i < element.getUseContext().size(); i++) {
7521      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
7522    }
7523    for (int i = 0; i < element.getJurisdiction().size(); i++) {
7524      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
7525    }
7526    if (element.hasPurposeElement()) {
7527      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
7528    }
7529    if (element.hasCopyrightElement()) {
7530      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
7531    }
7532    if (element.hasCopyrightLabelElement()) {
7533      composeString(t, "ConceptMap", "copyrightLabel", element.getCopyrightLabelElement(), -1);
7534    }
7535    if (element.hasApprovalDateElement()) {
7536      composeDate(t, "ConceptMap", "approvalDate", element.getApprovalDateElement(), -1);
7537    }
7538    if (element.hasLastReviewDateElement()) {
7539      composeDate(t, "ConceptMap", "lastReviewDate", element.getLastReviewDateElement(), -1);
7540    }
7541    if (element.hasEffectivePeriod()) {
7542      composePeriod(t, "ConceptMap", "effectivePeriod", element.getEffectivePeriod(), -1);
7543    }
7544    for (int i = 0; i < element.getTopic().size(); i++) {
7545      composeCodeableConcept(t, "ConceptMap", "topic", element.getTopic().get(i), i);
7546    }
7547    for (int i = 0; i < element.getAuthor().size(); i++) {
7548      composeContactDetail(t, "ConceptMap", "author", element.getAuthor().get(i), i);
7549    }
7550    for (int i = 0; i < element.getEditor().size(); i++) {
7551      composeContactDetail(t, "ConceptMap", "editor", element.getEditor().get(i), i);
7552    }
7553    for (int i = 0; i < element.getReviewer().size(); i++) {
7554      composeContactDetail(t, "ConceptMap", "reviewer", element.getReviewer().get(i), i);
7555    }
7556    for (int i = 0; i < element.getEndorser().size(); i++) {
7557      composeContactDetail(t, "ConceptMap", "endorser", element.getEndorser().get(i), i);
7558    }
7559    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
7560      composeRelatedArtifact(t, "ConceptMap", "relatedArtifact", element.getRelatedArtifact().get(i), i);
7561    }
7562    for (int i = 0; i < element.getProperty().size(); i++) {
7563      composeConceptMapPropertyComponent(t, "ConceptMap", "property", element.getProperty().get(i), i);
7564    }
7565    for (int i = 0; i < element.getAdditionalAttribute().size(); i++) {
7566      composeConceptMapAdditionalAttributeComponent(t, "ConceptMap", "additionalAttribute", element.getAdditionalAttribute().get(i), i);
7567    }
7568    if (element.hasSourceScope()) {
7569      composeType(t, "ConceptMap", "sourceScope", element.getSourceScope(), -1);
7570    }
7571    if (element.hasTargetScope()) {
7572      composeType(t, "ConceptMap", "targetScope", element.getTargetScope(), -1);
7573    }
7574    for (int i = 0; i < element.getGroup().size(); i++) {
7575      composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
7576    }
7577  }
7578
7579  protected void composeConceptMapPropertyComponent(Complex parent, String parentType, String name, ConceptMap.PropertyComponent element, int index) {
7580    if (element == null) 
7581      return;
7582    Complex t;
7583    if (Utilities.noString(parentType))
7584      t = parent;
7585    else {
7586      t = parent.predicate("fhir:"+name,index > -1);
7587    }
7588    composeBackboneElement(t, "property", name, element, index);
7589    if (element.hasCodeElement()) {
7590      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
7591    }
7592    if (element.hasUriElement()) {
7593      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
7594    }
7595    if (element.hasDescriptionElement()) {
7596      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
7597    }
7598    if (element.hasTypeElement()) {
7599      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
7600    }
7601    if (element.hasSystemElement()) {
7602      composeCanonical(t, "PropertyComponent", "system", element.getSystemElement(), -1);
7603    }
7604  }
7605
7606  protected void composeConceptMapAdditionalAttributeComponent(Complex parent, String parentType, String name, ConceptMap.AdditionalAttributeComponent element, int index) {
7607    if (element == null) 
7608      return;
7609    Complex t;
7610    if (Utilities.noString(parentType))
7611      t = parent;
7612    else {
7613      t = parent.predicate("fhir:"+name,index > -1);
7614    }
7615    composeBackboneElement(t, "additionalAttribute", name, element, index);
7616    if (element.hasCodeElement()) {
7617      composeCode(t, "AdditionalAttributeComponent", "code", element.getCodeElement(), -1);
7618    }
7619    if (element.hasUriElement()) {
7620      composeUri(t, "AdditionalAttributeComponent", "uri", element.getUriElement(), -1);
7621    }
7622    if (element.hasDescriptionElement()) {
7623      composeString(t, "AdditionalAttributeComponent", "description", element.getDescriptionElement(), -1);
7624    }
7625    if (element.hasTypeElement()) {
7626      composeEnum(t, "AdditionalAttributeComponent", "type", element.getTypeElement(), -1);
7627    }
7628  }
7629
7630  protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
7631    if (element == null) 
7632      return;
7633    Complex t;
7634    if (Utilities.noString(parentType))
7635      t = parent;
7636    else {
7637      t = parent.predicate("fhir:"+name,index > -1);
7638    }
7639    composeBackboneElement(t, "group", name, element, index);
7640    if (element.hasSourceElement()) {
7641      composeCanonical(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1);
7642    }
7643    if (element.hasTargetElement()) {
7644      composeCanonical(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1);
7645    }
7646    for (int i = 0; i < element.getElement().size(); i++) {
7647      composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i);
7648    }
7649    if (element.hasUnmapped()) {
7650      composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1);
7651    }
7652  }
7653
7654  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
7655    if (element == null) 
7656      return;
7657    Complex t;
7658    if (Utilities.noString(parentType))
7659      t = parent;
7660    else {
7661      t = parent.predicate("fhir:"+name,index > -1);
7662    }
7663    composeBackboneElement(t, "element", name, element, index);
7664    if (element.hasCodeElement()) {
7665      composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1);
7666    }
7667    if (element.hasDisplayElement()) {
7668      composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1);
7669    }
7670    if (element.hasValueSetElement()) {
7671      composeCanonical(t, "SourceElementComponent", "valueSet", element.getValueSetElement(), -1);
7672    }
7673    if (element.hasNoMapElement()) {
7674      composeBoolean(t, "SourceElementComponent", "noMap", element.getNoMapElement(), -1);
7675    }
7676    for (int i = 0; i < element.getTarget().size(); i++) {
7677      composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i);
7678    }
7679  }
7680
7681  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
7682    if (element == null) 
7683      return;
7684    Complex t;
7685    if (Utilities.noString(parentType))
7686      t = parent;
7687    else {
7688      t = parent.predicate("fhir:"+name,index > -1);
7689    }
7690    composeBackboneElement(t, "target", name, element, index);
7691    if (element.hasCodeElement()) {
7692      composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1);
7693    }
7694    if (element.hasDisplayElement()) {
7695      composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1);
7696    }
7697    if (element.hasValueSetElement()) {
7698      composeCanonical(t, "TargetElementComponent", "valueSet", element.getValueSetElement(), -1);
7699    }
7700    if (element.hasRelationshipElement()) {
7701      composeEnum(t, "TargetElementComponent", "relationship", element.getRelationshipElement(), -1);
7702    }
7703    if (element.hasCommentElement()) {
7704      composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1);
7705    }
7706    for (int i = 0; i < element.getProperty().size(); i++) {
7707      composeConceptMapMappingPropertyComponent(t, "TargetElementComponent", "property", element.getProperty().get(i), i);
7708    }
7709    for (int i = 0; i < element.getDependsOn().size(); i++) {
7710      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i);
7711    }
7712    for (int i = 0; i < element.getProduct().size(); i++) {
7713      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i);
7714    }
7715  }
7716
7717  protected void composeConceptMapMappingPropertyComponent(Complex parent, String parentType, String name, ConceptMap.MappingPropertyComponent element, int index) {
7718    if (element == null) 
7719      return;
7720    Complex t;
7721    if (Utilities.noString(parentType))
7722      t = parent;
7723    else {
7724      t = parent.predicate("fhir:"+name,index > -1);
7725    }
7726    composeBackboneElement(t, "property", name, element, index);
7727    if (element.hasCodeElement()) {
7728      composeCode(t, "MappingPropertyComponent", "code", element.getCodeElement(), -1);
7729    }
7730    if (element.hasValue()) {
7731      composeType(t, "MappingPropertyComponent", "value", element.getValue(), -1);
7732    }
7733  }
7734
7735  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
7736    if (element == null) 
7737      return;
7738    Complex t;
7739    if (Utilities.noString(parentType))
7740      t = parent;
7741    else {
7742      t = parent.predicate("fhir:"+name,index > -1);
7743    }
7744    composeBackboneElement(t, "dependsOn", name, element, index);
7745    if (element.hasAttributeElement()) {
7746      composeCode(t, "OtherElementComponent", "attribute", element.getAttributeElement(), -1);
7747    }
7748    if (element.hasValue()) {
7749      composeType(t, "OtherElementComponent", "value", element.getValue(), -1);
7750    }
7751    if (element.hasValueSetElement()) {
7752      composeCanonical(t, "OtherElementComponent", "valueSet", element.getValueSetElement(), -1);
7753    }
7754  }
7755
7756  protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
7757    if (element == null) 
7758      return;
7759    Complex t;
7760    if (Utilities.noString(parentType))
7761      t = parent;
7762    else {
7763      t = parent.predicate("fhir:"+name,index > -1);
7764    }
7765    composeBackboneElement(t, "unmapped", name, element, index);
7766    if (element.hasModeElement()) {
7767      composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1);
7768    }
7769    if (element.hasCodeElement()) {
7770      composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1);
7771    }
7772    if (element.hasDisplayElement()) {
7773      composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1);
7774    }
7775    if (element.hasValueSetElement()) {
7776      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "valueSet", element.getValueSetElement(), -1);
7777    }
7778    if (element.hasRelationshipElement()) {
7779      composeEnum(t, "ConceptMapGroupUnmappedComponent", "relationship", element.getRelationshipElement(), -1);
7780    }
7781    if (element.hasOtherMapElement()) {
7782      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "otherMap", element.getOtherMapElement(), -1);
7783    }
7784  }
7785
7786  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
7787    if (element == null) 
7788      return;
7789    Complex t;
7790    if (Utilities.noString(parentType))
7791      t = parent;
7792    else {
7793      t = parent.predicate("fhir:"+name,index > -1);
7794    }
7795    composeDomainResource(t, "Condition", name, element, index);
7796    for (int i = 0; i < element.getIdentifier().size(); i++) {
7797      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
7798    }
7799    if (element.hasClinicalStatus()) {
7800      composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1);
7801    }
7802    if (element.hasVerificationStatus()) {
7803      composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1);
7804    }
7805    for (int i = 0; i < element.getCategory().size(); i++) {
7806      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
7807    }
7808    if (element.hasSeverity()) {
7809      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
7810    }
7811    if (element.hasCode()) {
7812      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
7813    }
7814    for (int i = 0; i < element.getBodySite().size(); i++) {
7815      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
7816    }
7817    if (element.hasSubject()) {
7818      composeReference(t, "Condition", "subject", element.getSubject(), -1);
7819    }
7820    if (element.hasEncounter()) {
7821      composeReference(t, "Condition", "encounter", element.getEncounter(), -1);
7822    }
7823    if (element.hasOnset()) {
7824      composeType(t, "Condition", "onset", element.getOnset(), -1);
7825    }
7826    if (element.hasAbatement()) {
7827      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
7828    }
7829    if (element.hasRecordedDateElement()) {
7830      composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1);
7831    }
7832    for (int i = 0; i < element.getParticipant().size(); i++) {
7833      composeConditionParticipantComponent(t, "Condition", "participant", element.getParticipant().get(i), i);
7834    }
7835    for (int i = 0; i < element.getStage().size(); i++) {
7836      composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i);
7837    }
7838    for (int i = 0; i < element.getEvidence().size(); i++) {
7839      composeCodeableReference(t, "Condition", "evidence", element.getEvidence().get(i), i);
7840    }
7841    for (int i = 0; i < element.getNote().size(); i++) {
7842      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
7843    }
7844  }
7845
7846  protected void composeConditionParticipantComponent(Complex parent, String parentType, String name, Condition.ConditionParticipantComponent element, int index) {
7847    if (element == null) 
7848      return;
7849    Complex t;
7850    if (Utilities.noString(parentType))
7851      t = parent;
7852    else {
7853      t = parent.predicate("fhir:"+name,index > -1);
7854    }
7855    composeBackboneElement(t, "participant", name, element, index);
7856    if (element.hasFunction()) {
7857      composeCodeableConcept(t, "ConditionParticipantComponent", "function", element.getFunction(), -1);
7858    }
7859    if (element.hasActor()) {
7860      composeReference(t, "ConditionParticipantComponent", "actor", element.getActor(), -1);
7861    }
7862  }
7863
7864  protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
7865    if (element == null) 
7866      return;
7867    Complex t;
7868    if (Utilities.noString(parentType))
7869      t = parent;
7870    else {
7871      t = parent.predicate("fhir:"+name,index > -1);
7872    }
7873    composeBackboneElement(t, "stage", name, element, index);
7874    if (element.hasSummary()) {
7875      composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1);
7876    }
7877    for (int i = 0; i < element.getAssessment().size(); i++) {
7878      composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i);
7879    }
7880    if (element.hasType()) {
7881      composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1);
7882    }
7883  }
7884
7885  protected void composeConditionDefinition(Complex parent, String parentType, String name, ConditionDefinition element, int index) {
7886    if (element == null) 
7887      return;
7888    Complex t;
7889    if (Utilities.noString(parentType))
7890      t = parent;
7891    else {
7892      t = parent.predicate("fhir:"+name,index > -1);
7893    }
7894    composeMetadataResource(t, "ConditionDefinition", name, element, index);
7895    if (element.hasUrlElement()) {
7896      composeUri(t, "ConditionDefinition", "url", element.getUrlElement(), -1);
7897    }
7898    for (int i = 0; i < element.getIdentifier().size(); i++) {
7899      composeIdentifier(t, "ConditionDefinition", "identifier", element.getIdentifier().get(i), i);
7900    }
7901    if (element.hasVersionElement()) {
7902      composeString(t, "ConditionDefinition", "version", element.getVersionElement(), -1);
7903    }
7904    if (element.hasVersionAlgorithm()) {
7905      composeType(t, "ConditionDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1);
7906    }
7907    if (element.hasNameElement()) {
7908      composeString(t, "ConditionDefinition", "name", element.getNameElement(), -1);
7909    }
7910    if (element.hasTitleElement()) {
7911      composeString(t, "ConditionDefinition", "title", element.getTitleElement(), -1);
7912    }
7913    if (element.hasSubtitleElement()) {
7914      composeString(t, "ConditionDefinition", "subtitle", element.getSubtitleElement(), -1);
7915    }
7916    if (element.hasStatusElement()) {
7917      composeEnum(t, "ConditionDefinition", "status", element.getStatusElement(), -1);
7918    }
7919    if (element.hasExperimentalElement()) {
7920      composeBoolean(t, "ConditionDefinition", "experimental", element.getExperimentalElement(), -1);
7921    }
7922    if (element.hasDateElement()) {
7923      composeDateTime(t, "ConditionDefinition", "date", element.getDateElement(), -1);
7924    }
7925    if (element.hasPublisherElement()) {
7926      composeString(t, "ConditionDefinition", "publisher", element.getPublisherElement(), -1);
7927    }
7928    for (int i = 0; i < element.getContact().size(); i++) {
7929      composeContactDetail(t, "ConditionDefinition", "contact", element.getContact().get(i), i);
7930    }
7931    if (element.hasDescriptionElement()) {
7932      composeMarkdown(t, "ConditionDefinition", "description", element.getDescriptionElement(), -1);
7933    }
7934    for (int i = 0; i < element.getUseContext().size(); i++) {
7935      composeUsageContext(t, "ConditionDefinition", "useContext", element.getUseContext().get(i), i);
7936    }
7937    for (int i = 0; i < element.getJurisdiction().size(); i++) {
7938      composeCodeableConcept(t, "ConditionDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
7939    }
7940    if (element.hasCode()) {
7941      composeCodeableConcept(t, "ConditionDefinition", "code", element.getCode(), -1);
7942    }
7943    if (element.hasSeverity()) {
7944      composeCodeableConcept(t, "ConditionDefinition", "severity", element.getSeverity(), -1);
7945    }
7946    if (element.hasBodySite()) {
7947      composeCodeableConcept(t, "ConditionDefinition", "bodySite", element.getBodySite(), -1);
7948    }
7949    if (element.hasStage()) {
7950      composeCodeableConcept(t, "ConditionDefinition", "stage", element.getStage(), -1);
7951    }
7952    if (element.hasHasSeverityElement()) {
7953      composeBoolean(t, "ConditionDefinition", "hasSeverity", element.getHasSeverityElement(), -1);
7954    }
7955    if (element.hasHasBodySiteElement()) {
7956      composeBoolean(t, "ConditionDefinition", "hasBodySite", element.getHasBodySiteElement(), -1);
7957    }
7958    if (element.hasHasStageElement()) {
7959      composeBoolean(t, "ConditionDefinition", "hasStage", element.getHasStageElement(), -1);
7960    }
7961    for (int i = 0; i < element.getDefinition().size(); i++) {
7962      composeUri(t, "ConditionDefinition", "definition", element.getDefinition().get(i), i);
7963    }
7964    for (int i = 0; i < element.getObservation().size(); i++) {
7965      composeConditionDefinitionObservationComponent(t, "ConditionDefinition", "observation", element.getObservation().get(i), i);
7966    }
7967    for (int i = 0; i < element.getMedication().size(); i++) {
7968      composeConditionDefinitionMedicationComponent(t, "ConditionDefinition", "medication", element.getMedication().get(i), i);
7969    }
7970    for (int i = 0; i < element.getPrecondition().size(); i++) {
7971      composeConditionDefinitionPreconditionComponent(t, "ConditionDefinition", "precondition", element.getPrecondition().get(i), i);
7972    }
7973    for (int i = 0; i < element.getTeam().size(); i++) {
7974      composeReference(t, "ConditionDefinition", "team", element.getTeam().get(i), i);
7975    }
7976    for (int i = 0; i < element.getQuestionnaire().size(); i++) {
7977      composeConditionDefinitionQuestionnaireComponent(t, "ConditionDefinition", "questionnaire", element.getQuestionnaire().get(i), i);
7978    }
7979    for (int i = 0; i < element.getPlan().size(); i++) {
7980      composeConditionDefinitionPlanComponent(t, "ConditionDefinition", "plan", element.getPlan().get(i), i);
7981    }
7982  }
7983
7984  protected void composeConditionDefinitionObservationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionObservationComponent element, int index) {
7985    if (element == null) 
7986      return;
7987    Complex t;
7988    if (Utilities.noString(parentType))
7989      t = parent;
7990    else {
7991      t = parent.predicate("fhir:"+name,index > -1);
7992    }
7993    composeBackboneElement(t, "observation", name, element, index);
7994    if (element.hasCategory()) {
7995      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "category", element.getCategory(), -1);
7996    }
7997    if (element.hasCode()) {
7998      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "code", element.getCode(), -1);
7999    }
8000  }
8001
8002  protected void composeConditionDefinitionMedicationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionMedicationComponent element, int index) {
8003    if (element == null) 
8004      return;
8005    Complex t;
8006    if (Utilities.noString(parentType))
8007      t = parent;
8008    else {
8009      t = parent.predicate("fhir:"+name,index > -1);
8010    }
8011    composeBackboneElement(t, "medication", name, element, index);
8012    if (element.hasCategory()) {
8013      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "category", element.getCategory(), -1);
8014    }
8015    if (element.hasCode()) {
8016      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "code", element.getCode(), -1);
8017    }
8018  }
8019
8020  protected void composeConditionDefinitionPreconditionComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPreconditionComponent element, int index) {
8021    if (element == null) 
8022      return;
8023    Complex t;
8024    if (Utilities.noString(parentType))
8025      t = parent;
8026    else {
8027      t = parent.predicate("fhir:"+name,index > -1);
8028    }
8029    composeBackboneElement(t, "precondition", name, element, index);
8030    if (element.hasTypeElement()) {
8031      composeEnum(t, "ConditionDefinitionPreconditionComponent", "type", element.getTypeElement(), -1);
8032    }
8033    if (element.hasCode()) {
8034      composeCodeableConcept(t, "ConditionDefinitionPreconditionComponent", "code", element.getCode(), -1);
8035    }
8036    if (element.hasValue()) {
8037      composeType(t, "ConditionDefinitionPreconditionComponent", "value", element.getValue(), -1);
8038    }
8039  }
8040
8041  protected void composeConditionDefinitionQuestionnaireComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionQuestionnaireComponent element, int index) {
8042    if (element == null) 
8043      return;
8044    Complex t;
8045    if (Utilities.noString(parentType))
8046      t = parent;
8047    else {
8048      t = parent.predicate("fhir:"+name,index > -1);
8049    }
8050    composeBackboneElement(t, "questionnaire", name, element, index);
8051    if (element.hasPurposeElement()) {
8052      composeEnum(t, "ConditionDefinitionQuestionnaireComponent", "purpose", element.getPurposeElement(), -1);
8053    }
8054    if (element.hasReference()) {
8055      composeReference(t, "ConditionDefinitionQuestionnaireComponent", "reference", element.getReference(), -1);
8056    }
8057  }
8058
8059  protected void composeConditionDefinitionPlanComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPlanComponent element, int index) {
8060    if (element == null) 
8061      return;
8062    Complex t;
8063    if (Utilities.noString(parentType))
8064      t = parent;
8065    else {
8066      t = parent.predicate("fhir:"+name,index > -1);
8067    }
8068    composeBackboneElement(t, "plan", name, element, index);
8069    if (element.hasRole()) {
8070      composeCodeableConcept(t, "ConditionDefinitionPlanComponent", "role", element.getRole(), -1);
8071    }
8072    if (element.hasReference()) {
8073      composeReference(t, "ConditionDefinitionPlanComponent", "reference", element.getReference(), -1);
8074    }
8075  }
8076
8077  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
8078    if (element == null) 
8079      return;
8080    Complex t;
8081    if (Utilities.noString(parentType))
8082      t = parent;
8083    else {
8084      t = parent.predicate("fhir:"+name,index > -1);
8085    }
8086    composeDomainResource(t, "Consent", name, element, index);
8087    for (int i = 0; i < element.getIdentifier().size(); i++) {
8088      composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i);
8089    }
8090    if (element.hasStatusElement()) {
8091      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
8092    }
8093    for (int i = 0; i < element.getCategory().size(); i++) {
8094      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
8095    }
8096    if (element.hasSubject()) {
8097      composeReference(t, "Consent", "subject", element.getSubject(), -1);
8098    }
8099    if (element.hasDateElement()) {
8100      composeDate(t, "Consent", "date", element.getDateElement(), -1);
8101    }
8102    if (element.hasPeriod()) {
8103      composePeriod(t, "Consent", "period", element.getPeriod(), -1);
8104    }
8105    for (int i = 0; i < element.getGrantor().size(); i++) {
8106      composeReference(t, "Consent", "grantor", element.getGrantor().get(i), i);
8107    }
8108    for (int i = 0; i < element.getGrantee().size(); i++) {
8109      composeReference(t, "Consent", "grantee", element.getGrantee().get(i), i);
8110    }
8111    for (int i = 0; i < element.getManager().size(); i++) {
8112      composeReference(t, "Consent", "manager", element.getManager().get(i), i);
8113    }
8114    for (int i = 0; i < element.getController().size(); i++) {
8115      composeReference(t, "Consent", "controller", element.getController().get(i), i);
8116    }
8117    for (int i = 0; i < element.getSourceAttachment().size(); i++) {
8118      composeAttachment(t, "Consent", "sourceAttachment", element.getSourceAttachment().get(i), i);
8119    }
8120    for (int i = 0; i < element.getSourceReference().size(); i++) {
8121      composeReference(t, "Consent", "sourceReference", element.getSourceReference().get(i), i);
8122    }
8123    for (int i = 0; i < element.getRegulatoryBasis().size(); i++) {
8124      composeCodeableConcept(t, "Consent", "regulatoryBasis", element.getRegulatoryBasis().get(i), i);
8125    }
8126    if (element.hasPolicyBasis()) {
8127      composeConsentPolicyBasisComponent(t, "Consent", "policyBasis", element.getPolicyBasis(), -1);
8128    }
8129    for (int i = 0; i < element.getPolicyText().size(); i++) {
8130      composeReference(t, "Consent", "policyText", element.getPolicyText().get(i), i);
8131    }
8132    for (int i = 0; i < element.getVerification().size(); i++) {
8133      composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i);
8134    }
8135    if (element.hasDecisionElement()) {
8136      composeEnum(t, "Consent", "decision", element.getDecisionElement(), -1);
8137    }
8138    for (int i = 0; i < element.getProvision().size(); i++) {
8139      composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision().get(i), i);
8140    }
8141  }
8142
8143  protected void composeConsentPolicyBasisComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyBasisComponent element, int index) {
8144    if (element == null) 
8145      return;
8146    Complex t;
8147    if (Utilities.noString(parentType))
8148      t = parent;
8149    else {
8150      t = parent.predicate("fhir:"+name,index > -1);
8151    }
8152    composeBackboneElement(t, "policyBasis", name, element, index);
8153    if (element.hasReference()) {
8154      composeReference(t, "ConsentPolicyBasisComponent", "reference", element.getReference(), -1);
8155    }
8156    if (element.hasUrlElement()) {
8157      composeUrl(t, "ConsentPolicyBasisComponent", "url", element.getUrlElement(), -1);
8158    }
8159  }
8160
8161  protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) {
8162    if (element == null) 
8163      return;
8164    Complex t;
8165    if (Utilities.noString(parentType))
8166      t = parent;
8167    else {
8168      t = parent.predicate("fhir:"+name,index > -1);
8169    }
8170    composeBackboneElement(t, "verification", name, element, index);
8171    if (element.hasVerifiedElement()) {
8172      composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1);
8173    }
8174    if (element.hasVerificationType()) {
8175      composeCodeableConcept(t, "ConsentVerificationComponent", "verificationType", element.getVerificationType(), -1);
8176    }
8177    if (element.hasVerifiedBy()) {
8178      composeReference(t, "ConsentVerificationComponent", "verifiedBy", element.getVerifiedBy(), -1);
8179    }
8180    if (element.hasVerifiedWith()) {
8181      composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1);
8182    }
8183    for (int i = 0; i < element.getVerificationDate().size(); i++) {
8184      composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDate().get(i), i);
8185    }
8186  }
8187
8188  protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) {
8189    if (element == null) 
8190      return;
8191    Complex t;
8192    if (Utilities.noString(parentType))
8193      t = parent;
8194    else {
8195      t = parent.predicate("fhir:"+name,index > -1);
8196    }
8197    composeBackboneElement(t, "provision", name, element, index);
8198    if (element.hasPeriod()) {
8199      composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1);
8200    }
8201    for (int i = 0; i < element.getActor().size(); i++) {
8202      composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i);
8203    }
8204    for (int i = 0; i < element.getAction().size(); i++) {
8205      composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i);
8206    }
8207    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
8208      composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i);
8209    }
8210    for (int i = 0; i < element.getPurpose().size(); i++) {
8211      composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i);
8212    }
8213    for (int i = 0; i < element.getDocumentType().size(); i++) {
8214      composeCoding(t, "ProvisionComponent", "documentType", element.getDocumentType().get(i), i);
8215    }
8216    for (int i = 0; i < element.getResourceType().size(); i++) {
8217      composeCoding(t, "ProvisionComponent", "resourceType", element.getResourceType().get(i), i);
8218    }
8219    for (int i = 0; i < element.getCode().size(); i++) {
8220      composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i);
8221    }
8222    if (element.hasDataPeriod()) {
8223      composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1);
8224    }
8225    for (int i = 0; i < element.getData().size(); i++) {
8226      composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i);
8227    }
8228    if (element.hasExpression()) {
8229      composeExpression(t, "ProvisionComponent", "expression", element.getExpression(), -1);
8230    }
8231    for (int i = 0; i < element.getProvision().size(); i++) {
8232      composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i);
8233    }
8234  }
8235
8236  protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) {
8237    if (element == null) 
8238      return;
8239    Complex t;
8240    if (Utilities.noString(parentType))
8241      t = parent;
8242    else {
8243      t = parent.predicate("fhir:"+name,index > -1);
8244    }
8245    composeBackboneElement(t, "actor", name, element, index);
8246    if (element.hasRole()) {
8247      composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1);
8248    }
8249    if (element.hasReference()) {
8250      composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1);
8251    }
8252  }
8253
8254  protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent element, int index) {
8255    if (element == null) 
8256      return;
8257    Complex t;
8258    if (Utilities.noString(parentType))
8259      t = parent;
8260    else {
8261      t = parent.predicate("fhir:"+name,index > -1);
8262    }
8263    composeBackboneElement(t, "data", name, element, index);
8264    if (element.hasMeaningElement()) {
8265      composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1);
8266    }
8267    if (element.hasReference()) {
8268      composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1);
8269    }
8270  }
8271
8272  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
8273    if (element == null) 
8274      return;
8275    Complex t;
8276    if (Utilities.noString(parentType))
8277      t = parent;
8278    else {
8279      t = parent.predicate("fhir:"+name,index > -1);
8280    }
8281    composeDomainResource(t, "Contract", name, element, index);
8282    for (int i = 0; i < element.getIdentifier().size(); i++) {
8283      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
8284    }
8285    if (element.hasUrlElement()) {
8286      composeUri(t, "Contract", "url", element.getUrlElement(), -1);
8287    }
8288    if (element.hasVersionElement()) {
8289      composeString(t, "Contract", "version", element.getVersionElement(), -1);
8290    }
8291    if (element.hasStatusElement()) {
8292      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
8293    }
8294    if (element.hasLegalState()) {
8295      composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1);
8296    }
8297    if (element.hasInstantiatesCanonical()) {
8298      composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1);
8299    }
8300    if (element.hasInstantiatesUriElement()) {
8301      composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1);
8302    }
8303    if (element.hasContentDerivative()) {
8304      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
8305    }
8306    if (element.hasIssuedElement()) {
8307      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
8308    }
8309    if (element.hasApplies()) {
8310      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
8311    }
8312    if (element.hasExpirationType()) {
8313      composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1);
8314    }
8315    for (int i = 0; i < element.getSubject().size(); i++) {
8316      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
8317    }
8318    for (int i = 0; i < element.getAuthority().size(); i++) {
8319      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
8320    }
8321    for (int i = 0; i < element.getDomain().size(); i++) {
8322      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
8323    }
8324    for (int i = 0; i < element.getSite().size(); i++) {
8325      composeReference(t, "Contract", "site", element.getSite().get(i), i);
8326    }
8327    if (element.hasNameElement()) {
8328      composeString(t, "Contract", "name", element.getNameElement(), -1);
8329    }
8330    if (element.hasTitleElement()) {
8331      composeString(t, "Contract", "title", element.getTitleElement(), -1);
8332    }
8333    if (element.hasSubtitleElement()) {
8334      composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1);
8335    }
8336    for (int i = 0; i < element.getAlias().size(); i++) {
8337      composeString(t, "Contract", "alias", element.getAlias().get(i), i);
8338    }
8339    if (element.hasAuthor()) {
8340      composeReference(t, "Contract", "author", element.getAuthor(), -1);
8341    }
8342    if (element.hasScope()) {
8343      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
8344    }
8345    if (element.hasTopic()) {
8346      composeType(t, "Contract", "topic", element.getTopic(), -1);
8347    }
8348    if (element.hasType()) {
8349      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
8350    }
8351    for (int i = 0; i < element.getSubType().size(); i++) {
8352      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
8353    }
8354    if (element.hasContentDefinition()) {
8355      composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1);
8356    }
8357    for (int i = 0; i < element.getTerm().size(); i++) {
8358      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
8359    }
8360    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
8361      composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i);
8362    }
8363    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
8364      composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i);
8365    }
8366    for (int i = 0; i < element.getSigner().size(); i++) {
8367      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
8368    }
8369    for (int i = 0; i < element.getFriendly().size(); i++) {
8370      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
8371    }
8372    for (int i = 0; i < element.getLegal().size(); i++) {
8373      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
8374    }
8375    for (int i = 0; i < element.getRule().size(); i++) {
8376      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
8377    }
8378    if (element.hasLegallyBinding()) {
8379      composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1);
8380    }
8381  }
8382
8383  protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) {
8384    if (element == null) 
8385      return;
8386    Complex t;
8387    if (Utilities.noString(parentType))
8388      t = parent;
8389    else {
8390      t = parent.predicate("fhir:"+name,index > -1);
8391    }
8392    composeBackboneElement(t, "contentDefinition", name, element, index);
8393    if (element.hasType()) {
8394      composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1);
8395    }
8396    if (element.hasSubType()) {
8397      composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1);
8398    }
8399    if (element.hasPublisher()) {
8400      composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1);
8401    }
8402    if (element.hasPublicationDateElement()) {
8403      composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1);
8404    }
8405    if (element.hasPublicationStatusElement()) {
8406      composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1);
8407    }
8408    if (element.hasCopyrightElement()) {
8409      composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1);
8410    }
8411  }
8412
8413  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
8414    if (element == null) 
8415      return;
8416    Complex t;
8417    if (Utilities.noString(parentType))
8418      t = parent;
8419    else {
8420      t = parent.predicate("fhir:"+name,index > -1);
8421    }
8422    composeBackboneElement(t, "term", name, element, index);
8423    if (element.hasIdentifier()) {
8424      composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1);
8425    }
8426    if (element.hasIssuedElement()) {
8427      composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1);
8428    }
8429    if (element.hasApplies()) {
8430      composePeriod(t, "TermComponent", "applies", element.getApplies(), -1);
8431    }
8432    if (element.hasTopic()) {
8433      composeType(t, "TermComponent", "topic", element.getTopic(), -1);
8434    }
8435    if (element.hasType()) {
8436      composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1);
8437    }
8438    if (element.hasSubType()) {
8439      composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1);
8440    }
8441    if (element.hasTextElement()) {
8442      composeString(t, "TermComponent", "text", element.getTextElement(), -1);
8443    }
8444    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
8445      composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i);
8446    }
8447    if (element.hasOffer()) {
8448      composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1);
8449    }
8450    for (int i = 0; i < element.getAsset().size(); i++) {
8451      composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i);
8452    }
8453    for (int i = 0; i < element.getAction().size(); i++) {
8454      composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i);
8455    }
8456    for (int i = 0; i < element.getGroup().size(); i++) {
8457      composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i);
8458    }
8459  }
8460
8461  protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) {
8462    if (element == null) 
8463      return;
8464    Complex t;
8465    if (Utilities.noString(parentType))
8466      t = parent;
8467    else {
8468      t = parent.predicate("fhir:"+name,index > -1);
8469    }
8470    composeBackboneElement(t, "securityLabel", name, element, index);
8471    for (int i = 0; i < element.getNumber().size(); i++) {
8472      composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i);
8473    }
8474    if (element.hasClassification()) {
8475      composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1);
8476    }
8477    for (int i = 0; i < element.getCategory().size(); i++) {
8478      composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i);
8479    }
8480    for (int i = 0; i < element.getControl().size(); i++) {
8481      composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i);
8482    }
8483  }
8484
8485  protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) {
8486    if (element == null) 
8487      return;
8488    Complex t;
8489    if (Utilities.noString(parentType))
8490      t = parent;
8491    else {
8492      t = parent.predicate("fhir:"+name,index > -1);
8493    }
8494    composeBackboneElement(t, "offer", name, element, index);
8495    for (int i = 0; i < element.getIdentifier().size(); i++) {
8496      composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i);
8497    }
8498    for (int i = 0; i < element.getParty().size(); i++) {
8499      composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i);
8500    }
8501    if (element.hasTopic()) {
8502      composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1);
8503    }
8504    if (element.hasType()) {
8505      composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1);
8506    }
8507    if (element.hasDecision()) {
8508      composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1);
8509    }
8510    for (int i = 0; i < element.getDecisionMode().size(); i++) {
8511      composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i);
8512    }
8513    for (int i = 0; i < element.getAnswer().size(); i++) {
8514      composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i);
8515    }
8516    if (element.hasTextElement()) {
8517      composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1);
8518    }
8519    for (int i = 0; i < element.getLinkId().size(); i++) {
8520      composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i);
8521    }
8522    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
8523      composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
8524    }
8525  }
8526
8527  protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) {
8528    if (element == null) 
8529      return;
8530    Complex t;
8531    if (Utilities.noString(parentType))
8532      t = parent;
8533    else {
8534      t = parent.predicate("fhir:"+name,index > -1);
8535    }
8536    composeBackboneElement(t, "party", name, element, index);
8537    for (int i = 0; i < element.getReference().size(); i++) {
8538      composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i);
8539    }
8540    if (element.hasRole()) {
8541      composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1);
8542    }
8543  }
8544
8545  protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) {
8546    if (element == null) 
8547      return;
8548    Complex t;
8549    if (Utilities.noString(parentType))
8550      t = parent;
8551    else {
8552      t = parent.predicate("fhir:"+name,index > -1);
8553    }
8554    composeBackboneElement(t, "answer", name, element, index);
8555    if (element.hasValue()) {
8556      composeType(t, "AnswerComponent", "value", element.getValue(), -1);
8557    }
8558  }
8559
8560  protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) {
8561    if (element == null) 
8562      return;
8563    Complex t;
8564    if (Utilities.noString(parentType))
8565      t = parent;
8566    else {
8567      t = parent.predicate("fhir:"+name,index > -1);
8568    }
8569    composeBackboneElement(t, "asset", name, element, index);
8570    if (element.hasScope()) {
8571      composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1);
8572    }
8573    for (int i = 0; i < element.getType().size(); i++) {
8574      composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i);
8575    }
8576    for (int i = 0; i < element.getTypeReference().size(); i++) {
8577      composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i);
8578    }
8579    for (int i = 0; i < element.getSubtype().size(); i++) {
8580      composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i);
8581    }
8582    if (element.hasRelationship()) {
8583      composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1);
8584    }
8585    for (int i = 0; i < element.getContext().size(); i++) {
8586      composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i);
8587    }
8588    if (element.hasConditionElement()) {
8589      composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1);
8590    }
8591    for (int i = 0; i < element.getPeriodType().size(); i++) {
8592      composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i);
8593    }
8594    for (int i = 0; i < element.getPeriod().size(); i++) {
8595      composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i);
8596    }
8597    for (int i = 0; i < element.getUsePeriod().size(); i++) {
8598      composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i);
8599    }
8600    if (element.hasTextElement()) {
8601      composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1);
8602    }
8603    for (int i = 0; i < element.getLinkId().size(); i++) {
8604      composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i);
8605    }
8606    for (int i = 0; i < element.getAnswer().size(); i++) {
8607      composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i);
8608    }
8609    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
8610      composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
8611    }
8612    for (int i = 0; i < element.getValuedItem().size(); i++) {
8613      composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i);
8614    }
8615  }
8616
8617  protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) {
8618    if (element == null) 
8619      return;
8620    Complex t;
8621    if (Utilities.noString(parentType))
8622      t = parent;
8623    else {
8624      t = parent.predicate("fhir:"+name,index > -1);
8625    }
8626    composeBackboneElement(t, "context", name, element, index);
8627    if (element.hasReference()) {
8628      composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1);
8629    }
8630    for (int i = 0; i < element.getCode().size(); i++) {
8631      composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i);
8632    }
8633    if (element.hasTextElement()) {
8634      composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1);
8635    }
8636  }
8637
8638  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) {
8639    if (element == null) 
8640      return;
8641    Complex t;
8642    if (Utilities.noString(parentType))
8643      t = parent;
8644    else {
8645      t = parent.predicate("fhir:"+name,index > -1);
8646    }
8647    composeBackboneElement(t, "valuedItem", name, element, index);
8648    if (element.hasEntity()) {
8649      composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1);
8650    }
8651    if (element.hasIdentifier()) {
8652      composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1);
8653    }
8654    if (element.hasEffectiveTimeElement()) {
8655      composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1);
8656    }
8657    if (element.hasQuantity()) {
8658      composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1);
8659    }
8660    if (element.hasUnitPrice()) {
8661      composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1);
8662    }
8663    if (element.hasFactorElement()) {
8664      composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1);
8665    }
8666    if (element.hasPointsElement()) {
8667      composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1);
8668    }
8669    if (element.hasNet()) {
8670      composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1);
8671    }
8672    if (element.hasPaymentElement()) {
8673      composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1);
8674    }
8675    if (element.hasPaymentDateElement()) {
8676      composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1);
8677    }
8678    if (element.hasResponsible()) {
8679      composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1);
8680    }
8681    if (element.hasRecipient()) {
8682      composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1);
8683    }
8684    for (int i = 0; i < element.getLinkId().size(); i++) {
8685      composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i);
8686    }
8687    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
8688      composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
8689    }
8690  }
8691
8692  protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) {
8693    if (element == null) 
8694      return;
8695    Complex t;
8696    if (Utilities.noString(parentType))
8697      t = parent;
8698    else {
8699      t = parent.predicate("fhir:"+name,index > -1);
8700    }
8701    composeBackboneElement(t, "action", name, element, index);
8702    if (element.hasDoNotPerformElement()) {
8703      composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
8704    }
8705    if (element.hasType()) {
8706      composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1);
8707    }
8708    for (int i = 0; i < element.getSubject().size(); i++) {
8709      composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i);
8710    }
8711    if (element.hasIntent()) {
8712      composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1);
8713    }
8714    for (int i = 0; i < element.getLinkId().size(); i++) {
8715      composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i);
8716    }
8717    if (element.hasStatus()) {
8718      composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1);
8719    }
8720    if (element.hasContext()) {
8721      composeReference(t, "ActionComponent", "context", element.getContext(), -1);
8722    }
8723    for (int i = 0; i < element.getContextLinkId().size(); i++) {
8724      composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i);
8725    }
8726    if (element.hasOccurrence()) {
8727      composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1);
8728    }
8729    for (int i = 0; i < element.getRequester().size(); i++) {
8730      composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i);
8731    }
8732    for (int i = 0; i < element.getRequesterLinkId().size(); i++) {
8733      composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i);
8734    }
8735    for (int i = 0; i < element.getPerformerType().size(); i++) {
8736      composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i);
8737    }
8738    if (element.hasPerformerRole()) {
8739      composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1);
8740    }
8741    if (element.hasPerformer()) {
8742      composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1);
8743    }
8744    for (int i = 0; i < element.getPerformerLinkId().size(); i++) {
8745      composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i);
8746    }
8747    for (int i = 0; i < element.getReason().size(); i++) {
8748      composeCodeableReference(t, "ActionComponent", "reason", element.getReason().get(i), i);
8749    }
8750    for (int i = 0; i < element.getReasonLinkId().size(); i++) {
8751      composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i);
8752    }
8753    for (int i = 0; i < element.getNote().size(); i++) {
8754      composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i);
8755    }
8756    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
8757      composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
8758    }
8759  }
8760
8761  protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) {
8762    if (element == null) 
8763      return;
8764    Complex t;
8765    if (Utilities.noString(parentType))
8766      t = parent;
8767    else {
8768      t = parent.predicate("fhir:"+name,index > -1);
8769    }
8770    composeBackboneElement(t, "subject", name, element, index);
8771    for (int i = 0; i < element.getReference().size(); i++) {
8772      composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i);
8773    }
8774    if (element.hasRole()) {
8775      composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1);
8776    }
8777  }
8778
8779  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
8780    if (element == null) 
8781      return;
8782    Complex t;
8783    if (Utilities.noString(parentType))
8784      t = parent;
8785    else {
8786      t = parent.predicate("fhir:"+name,index > -1);
8787    }
8788    composeBackboneElement(t, "signer", name, element, index);
8789    if (element.hasType()) {
8790      composeCoding(t, "SignatoryComponent", "type", element.getType(), -1);
8791    }
8792    if (element.hasParty()) {
8793      composeReference(t, "SignatoryComponent", "party", element.getParty(), -1);
8794    }
8795    for (int i = 0; i < element.getSignature().size(); i++) {
8796      composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i);
8797    }
8798  }
8799
8800  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
8801    if (element == null) 
8802      return;
8803    Complex t;
8804    if (Utilities.noString(parentType))
8805      t = parent;
8806    else {
8807      t = parent.predicate("fhir:"+name,index > -1);
8808    }
8809    composeBackboneElement(t, "friendly", name, element, index);
8810    if (element.hasContent()) {
8811      composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1);
8812    }
8813  }
8814
8815  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
8816    if (element == null) 
8817      return;
8818    Complex t;
8819    if (Utilities.noString(parentType))
8820      t = parent;
8821    else {
8822      t = parent.predicate("fhir:"+name,index > -1);
8823    }
8824    composeBackboneElement(t, "legal", name, element, index);
8825    if (element.hasContent()) {
8826      composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1);
8827    }
8828  }
8829
8830  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
8831    if (element == null) 
8832      return;
8833    Complex t;
8834    if (Utilities.noString(parentType))
8835      t = parent;
8836    else {
8837      t = parent.predicate("fhir:"+name,index > -1);
8838    }
8839    composeBackboneElement(t, "rule", name, element, index);
8840    if (element.hasContent()) {
8841      composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1);
8842    }
8843  }
8844
8845  protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) {
8846    if (element == null) 
8847      return;
8848    Complex t;
8849    if (Utilities.noString(parentType))
8850      t = parent;
8851    else {
8852      t = parent.predicate("fhir:"+name,index > -1);
8853    }
8854    composeDomainResource(t, "Coverage", name, element, index);
8855    for (int i = 0; i < element.getIdentifier().size(); i++) {
8856      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
8857    }
8858    if (element.hasStatusElement()) {
8859      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
8860    }
8861    if (element.hasKindElement()) {
8862      composeEnum(t, "Coverage", "kind", element.getKindElement(), -1);
8863    }
8864    for (int i = 0; i < element.getPaymentBy().size(); i++) {
8865      composeCoveragePaymentByComponent(t, "Coverage", "paymentBy", element.getPaymentBy().get(i), i);
8866    }
8867    if (element.hasType()) {
8868      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
8869    }
8870    if (element.hasPolicyHolder()) {
8871      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
8872    }
8873    if (element.hasSubscriber()) {
8874      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
8875    }
8876    for (int i = 0; i < element.getSubscriberId().size(); i++) {
8877      composeIdentifier(t, "Coverage", "subscriberId", element.getSubscriberId().get(i), i);
8878    }
8879    if (element.hasBeneficiary()) {
8880      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
8881    }
8882    if (element.hasDependentElement()) {
8883      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
8884    }
8885    if (element.hasRelationship()) {
8886      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
8887    }
8888    if (element.hasPeriod()) {
8889      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
8890    }
8891    if (element.hasInsurer()) {
8892      composeReference(t, "Coverage", "insurer", element.getInsurer(), -1);
8893    }
8894    for (int i = 0; i < element.getClass_().size(); i++) {
8895      composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i);
8896    }
8897    if (element.hasOrderElement()) {
8898      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
8899    }
8900    if (element.hasNetworkElement()) {
8901      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
8902    }
8903    for (int i = 0; i < element.getCostToBeneficiary().size(); i++) {
8904      composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i);
8905    }
8906    if (element.hasSubrogationElement()) {
8907      composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1);
8908    }
8909    for (int i = 0; i < element.getContract().size(); i++) {
8910      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
8911    }
8912    if (element.hasInsurancePlan()) {
8913      composeReference(t, "Coverage", "insurancePlan", element.getInsurancePlan(), -1);
8914    }
8915  }
8916
8917  protected void composeCoveragePaymentByComponent(Complex parent, String parentType, String name, Coverage.CoveragePaymentByComponent element, int index) {
8918    if (element == null) 
8919      return;
8920    Complex t;
8921    if (Utilities.noString(parentType))
8922      t = parent;
8923    else {
8924      t = parent.predicate("fhir:"+name,index > -1);
8925    }
8926    composeBackboneElement(t, "paymentBy", name, element, index);
8927    if (element.hasParty()) {
8928      composeReference(t, "CoveragePaymentByComponent", "party", element.getParty(), -1);
8929    }
8930    if (element.hasResponsibilityElement()) {
8931      composeString(t, "CoveragePaymentByComponent", "responsibility", element.getResponsibilityElement(), -1);
8932    }
8933  }
8934
8935  protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) {
8936    if (element == null) 
8937      return;
8938    Complex t;
8939    if (Utilities.noString(parentType))
8940      t = parent;
8941    else {
8942      t = parent.predicate("fhir:"+name,index > -1);
8943    }
8944    composeBackboneElement(t, "class", name, element, index);
8945    if (element.hasType()) {
8946      composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1);
8947    }
8948    if (element.hasValue()) {
8949      composeIdentifier(t, "ClassComponent", "value", element.getValue(), -1);
8950    }
8951    if (element.hasNameElement()) {
8952      composeString(t, "ClassComponent", "name", element.getNameElement(), -1);
8953    }
8954  }
8955
8956  protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) {
8957    if (element == null) 
8958      return;
8959    Complex t;
8960    if (Utilities.noString(parentType))
8961      t = parent;
8962    else {
8963      t = parent.predicate("fhir:"+name,index > -1);
8964    }
8965    composeBackboneElement(t, "costToBeneficiary", name, element, index);
8966    if (element.hasType()) {
8967      composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1);
8968    }
8969    if (element.hasCategory()) {
8970      composeCodeableConcept(t, "CostToBeneficiaryComponent", "category", element.getCategory(), -1);
8971    }
8972    if (element.hasNetwork()) {
8973      composeCodeableConcept(t, "CostToBeneficiaryComponent", "network", element.getNetwork(), -1);
8974    }
8975    if (element.hasUnit()) {
8976      composeCodeableConcept(t, "CostToBeneficiaryComponent", "unit", element.getUnit(), -1);
8977    }
8978    if (element.hasTerm()) {
8979      composeCodeableConcept(t, "CostToBeneficiaryComponent", "term", element.getTerm(), -1);
8980    }
8981    if (element.hasValue()) {
8982      composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1);
8983    }
8984    for (int i = 0; i < element.getException().size(); i++) {
8985      composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i);
8986    }
8987  }
8988
8989  protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) {
8990    if (element == null) 
8991      return;
8992    Complex t;
8993    if (Utilities.noString(parentType))
8994      t = parent;
8995    else {
8996      t = parent.predicate("fhir:"+name,index > -1);
8997    }
8998    composeBackboneElement(t, "exception", name, element, index);
8999    if (element.hasType()) {
9000      composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1);
9001    }
9002    if (element.hasPeriod()) {
9003      composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1);
9004    }
9005  }
9006
9007  protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) {
9008    if (element == null) 
9009      return;
9010    Complex t;
9011    if (Utilities.noString(parentType))
9012      t = parent;
9013    else {
9014      t = parent.predicate("fhir:"+name,index > -1);
9015    }
9016    composeDomainResource(t, "CoverageEligibilityRequest", name, element, index);
9017    for (int i = 0; i < element.getIdentifier().size(); i++) {
9018      composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i);
9019    }
9020    if (element.hasStatusElement()) {
9021      composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1);
9022    }
9023    if (element.hasPriority()) {
9024      composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1);
9025    }
9026    for (int i = 0; i < element.getPurpose().size(); i++) {
9027      composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i);
9028    }
9029    if (element.hasPatient()) {
9030      composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1);
9031    }
9032    for (int i = 0; i < element.getEvent().size(); i++) {
9033      composeCoverageEligibilityRequestEventComponent(t, "CoverageEligibilityRequest", "event", element.getEvent().get(i), i);
9034    }
9035    if (element.hasServiced()) {
9036      composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1);
9037    }
9038    if (element.hasCreatedElement()) {
9039      composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1);
9040    }
9041    if (element.hasEnterer()) {
9042      composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1);
9043    }
9044    if (element.hasProvider()) {
9045      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
9046    }
9047    if (element.hasInsurer()) {
9048      composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1);
9049    }
9050    if (element.hasFacility()) {
9051      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
9052    }
9053    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
9054      composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
9055    }
9056    for (int i = 0; i < element.getInsurance().size(); i++) {
9057      composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i);
9058    }
9059    for (int i = 0; i < element.getItem().size(); i++) {
9060      composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i);
9061    }
9062  }
9063
9064  protected void composeCoverageEligibilityRequestEventComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.CoverageEligibilityRequestEventComponent element, int index) {
9065    if (element == null) 
9066      return;
9067    Complex t;
9068    if (Utilities.noString(parentType))
9069      t = parent;
9070    else {
9071      t = parent.predicate("fhir:"+name,index > -1);
9072    }
9073    composeBackboneElement(t, "event", name, element, index);
9074    if (element.hasType()) {
9075      composeCodeableConcept(t, "CoverageEligibilityRequestEventComponent", "type", element.getType(), -1);
9076    }
9077    if (element.hasWhen()) {
9078      composeType(t, "CoverageEligibilityRequestEventComponent", "when", element.getWhen(), -1);
9079    }
9080  }
9081
9082  protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) {
9083    if (element == null) 
9084      return;
9085    Complex t;
9086    if (Utilities.noString(parentType))
9087      t = parent;
9088    else {
9089      t = parent.predicate("fhir:"+name,index > -1);
9090    }
9091    composeBackboneElement(t, "supportingInfo", name, element, index);
9092    if (element.hasSequenceElement()) {
9093      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
9094    }
9095    if (element.hasInformation()) {
9096      composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1);
9097    }
9098    if (element.hasAppliesToAllElement()) {
9099      composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1);
9100    }
9101  }
9102
9103  protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) {
9104    if (element == null) 
9105      return;
9106    Complex t;
9107    if (Utilities.noString(parentType))
9108      t = parent;
9109    else {
9110      t = parent.predicate("fhir:"+name,index > -1);
9111    }
9112    composeBackboneElement(t, "insurance", name, element, index);
9113    if (element.hasFocalElement()) {
9114      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
9115    }
9116    if (element.hasCoverage()) {
9117      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
9118    }
9119    if (element.hasBusinessArrangementElement()) {
9120      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
9121    }
9122  }
9123
9124  protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) {
9125    if (element == null) 
9126      return;
9127    Complex t;
9128    if (Utilities.noString(parentType))
9129      t = parent;
9130    else {
9131      t = parent.predicate("fhir:"+name,index > -1);
9132    }
9133    composeBackboneElement(t, "item", name, element, index);
9134    for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) {
9135      composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i);
9136    }
9137    if (element.hasCategory()) {
9138      composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1);
9139    }
9140    if (element.hasProductOrService()) {
9141      composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1);
9142    }
9143    for (int i = 0; i < element.getModifier().size(); i++) {
9144      composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i);
9145    }
9146    if (element.hasProvider()) {
9147      composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1);
9148    }
9149    if (element.hasQuantity()) {
9150      composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1);
9151    }
9152    if (element.hasUnitPrice()) {
9153      composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1);
9154    }
9155    if (element.hasFacility()) {
9156      composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1);
9157    }
9158    for (int i = 0; i < element.getDiagnosis().size(); i++) {
9159      composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i);
9160    }
9161    for (int i = 0; i < element.getDetail().size(); i++) {
9162      composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i);
9163    }
9164  }
9165
9166  protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) {
9167    if (element == null) 
9168      return;
9169    Complex t;
9170    if (Utilities.noString(parentType))
9171      t = parent;
9172    else {
9173      t = parent.predicate("fhir:"+name,index > -1);
9174    }
9175    composeBackboneElement(t, "diagnosis", name, element, index);
9176    if (element.hasDiagnosis()) {
9177      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
9178    }
9179  }
9180
9181  protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) {
9182    if (element == null) 
9183      return;
9184    Complex t;
9185    if (Utilities.noString(parentType))
9186      t = parent;
9187    else {
9188      t = parent.predicate("fhir:"+name,index > -1);
9189    }
9190    composeDomainResource(t, "CoverageEligibilityResponse", name, element, index);
9191    for (int i = 0; i < element.getIdentifier().size(); i++) {
9192      composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i);
9193    }
9194    if (element.hasStatusElement()) {
9195      composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1);
9196    }
9197    for (int i = 0; i < element.getPurpose().size(); i++) {
9198      composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i);
9199    }
9200    if (element.hasPatient()) {
9201      composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1);
9202    }
9203    for (int i = 0; i < element.getEvent().size(); i++) {
9204      composeCoverageEligibilityResponseEventComponent(t, "CoverageEligibilityResponse", "event", element.getEvent().get(i), i);
9205    }
9206    if (element.hasServiced()) {
9207      composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1);
9208    }
9209    if (element.hasCreatedElement()) {
9210      composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1);
9211    }
9212    if (element.hasRequestor()) {
9213      composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1);
9214    }
9215    if (element.hasRequest()) {
9216      composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1);
9217    }
9218    if (element.hasOutcomeElement()) {
9219      composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1);
9220    }
9221    if (element.hasDispositionElement()) {
9222      composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1);
9223    }
9224    if (element.hasInsurer()) {
9225      composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1);
9226    }
9227    for (int i = 0; i < element.getInsurance().size(); i++) {
9228      composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i);
9229    }
9230    if (element.hasPreAuthRefElement()) {
9231      composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
9232    }
9233    if (element.hasForm()) {
9234      composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1);
9235    }
9236    for (int i = 0; i < element.getError().size(); i++) {
9237      composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i);
9238    }
9239  }
9240
9241  protected void composeCoverageEligibilityResponseEventComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.CoverageEligibilityResponseEventComponent element, int index) {
9242    if (element == null) 
9243      return;
9244    Complex t;
9245    if (Utilities.noString(parentType))
9246      t = parent;
9247    else {
9248      t = parent.predicate("fhir:"+name,index > -1);
9249    }
9250    composeBackboneElement(t, "event", name, element, index);
9251    if (element.hasType()) {
9252      composeCodeableConcept(t, "CoverageEligibilityResponseEventComponent", "type", element.getType(), -1);
9253    }
9254    if (element.hasWhen()) {
9255      composeType(t, "CoverageEligibilityResponseEventComponent", "when", element.getWhen(), -1);
9256    }
9257  }
9258
9259  protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) {
9260    if (element == null) 
9261      return;
9262    Complex t;
9263    if (Utilities.noString(parentType))
9264      t = parent;
9265    else {
9266      t = parent.predicate("fhir:"+name,index > -1);
9267    }
9268    composeBackboneElement(t, "insurance", name, element, index);
9269    if (element.hasCoverage()) {
9270      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
9271    }
9272    if (element.hasInforceElement()) {
9273      composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1);
9274    }
9275    if (element.hasBenefitPeriod()) {
9276      composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1);
9277    }
9278    for (int i = 0; i < element.getItem().size(); i++) {
9279      composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i);
9280    }
9281  }
9282
9283  protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) {
9284    if (element == null) 
9285      return;
9286    Complex t;
9287    if (Utilities.noString(parentType))
9288      t = parent;
9289    else {
9290      t = parent.predicate("fhir:"+name,index > -1);
9291    }
9292    composeBackboneElement(t, "item", name, element, index);
9293    if (element.hasCategory()) {
9294      composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1);
9295    }
9296    if (element.hasProductOrService()) {
9297      composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1);
9298    }
9299    for (int i = 0; i < element.getModifier().size(); i++) {
9300      composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i);
9301    }
9302    if (element.hasProvider()) {
9303      composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1);
9304    }
9305    if (element.hasExcludedElement()) {
9306      composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1);
9307    }
9308    if (element.hasNameElement()) {
9309      composeString(t, "ItemsComponent", "name", element.getNameElement(), -1);
9310    }
9311    if (element.hasDescriptionElement()) {
9312      composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1);
9313    }
9314    if (element.hasNetwork()) {
9315      composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1);
9316    }
9317    if (element.hasUnit()) {
9318      composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1);
9319    }
9320    if (element.hasTerm()) {
9321      composeCodeableConcept(t, "ItemsComponent", "term",