Source code

001package org.hl7.fhir.r4b.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 Wed, Dec 29, 2021 07:58+1100 for FHIR v4.3.0-snapshot1
035
036
037
038import org.hl7.fhir.r4b.model.*;
039import org.hl7.fhir.r4b.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:"+parentType+"."+name);
061    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
071    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
079    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
087    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
096    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
104    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
112    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
120    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
128    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
136    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
144    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
152    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
160    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
168    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
176    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
184    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
192    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
200    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
208    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
216    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
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:"+parentType+"."+name);
224    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
225    composeElement(t, parentType, name, value, index);
226  }
227
228  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
229    if (element.hasIdElement()) {
230      composeString(t, "Element", "id", element.getIdElement(), -1);
231    }
232    for (int i = 0; i < element.getExtension().size(); i++) {
233      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
234    }
235  }
236
237  protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) {
238    composeDataType(t, parentType, name, element, index);
239    for (int i = 0; i < element.getModifierExtension().size(); i++) {
240      composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i);
241    }
242  }
243
244  protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) {
245    composeDataType(t, parentType, name, element, index);
246  }
247
248  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
249    if (element == null) 
250      return;
251    Complex t;
252    if (Utilities.noString(parentType))
253      t = parent;
254    else {
255      t = parent.predicate("fhir:"+parentType+'.'+name);
256    }
257    composeDataType(t, "Address", name, element, index);
258    if (element.hasUseElement()) {
259      composeEnum(t, "Address", "use", element.getUseElement(), -1);
260    }
261    if (element.hasTypeElement()) {
262      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
263    }
264    if (element.hasTextElement()) {
265      composeString(t, "Address", "text", element.getTextElement(), -1);
266    }
267    for (int i = 0; i < element.getLine().size(); i++) {
268      composeString(t, "Address", "line", element.getLine().get(i), i);
269    }
270    if (element.hasCityElement()) {
271      composeString(t, "Address", "city", element.getCityElement(), -1);
272    }
273    if (element.hasDistrictElement()) {
274      composeString(t, "Address", "district", element.getDistrictElement(), -1);
275    }
276    if (element.hasStateElement()) {
277      composeString(t, "Address", "state", element.getStateElement(), -1);
278    }
279    if (element.hasPostalCodeElement()) {
280      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
281    }
282    if (element.hasCountryElement()) {
283      composeString(t, "Address", "country", element.getCountryElement(), -1);
284    }
285    if (element.hasPeriod()) {
286      composePeriod(t, "Address", "period", element.getPeriod(), -1);
287    }
288  }
289
290  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
291    if (element == null) 
292      return;
293    Complex t;
294    if (Utilities.noString(parentType))
295      t = parent;
296    else {
297      t = parent.predicate("fhir:"+parentType+'.'+name);
298    }
299    composeQuantity(t, "Age", name, element, index);
300  }
301
302  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
303    if (element == null) 
304      return;
305    Complex t;
306    if (Utilities.noString(parentType))
307      t = parent;
308    else {
309      t = parent.predicate("fhir:"+parentType+'.'+name);
310    }
311    composeDataType(t, "Annotation", name, element, index);
312    if (element.hasAuthor()) {
313      composeType(t, "Annotation", "author", element.getAuthor(), -1);
314    }
315    if (element.hasTimeElement()) {
316      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
317    }
318    if (element.hasTextElement()) {
319      composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1);
320    }
321  }
322
323  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
324    if (element == null) 
325      return;
326    Complex t;
327    if (Utilities.noString(parentType))
328      t = parent;
329    else {
330      t = parent.predicate("fhir:"+parentType+'.'+name);
331    }
332    composeDataType(t, "Attachment", name, element, index);
333    if (element.hasContentTypeElement()) {
334      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
335    }
336    if (element.hasLanguageElement()) {
337      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
338    }
339    if (element.hasDataElement()) {
340      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
341    }
342    if (element.hasUrlElement()) {
343      composeUrl(t, "Attachment", "url", element.getUrlElement(), -1);
344    }
345    if (element.hasSizeElement()) {
346      composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1);
347    }
348    if (element.hasHashElement()) {
349      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
350    }
351    if (element.hasTitleElement()) {
352      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
353    }
354    if (element.hasCreationElement()) {
355      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
356    }
357  }
358
359  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
360    if (element == null) 
361      return;
362    Complex t;
363    if (Utilities.noString(parentType))
364      t = parent;
365    else {
366      t = parent.predicate("fhir:"+parentType+'.'+name);
367    }
368    composeDataType(t, "CodeableConcept", name, element, index);
369    decorateCodeableConcept(t, element);
370    for (int i = 0; i < element.getCoding().size(); i++) {
371      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
372    }
373    if (element.hasTextElement()) {
374      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
375    }
376  }
377
378  protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) {
379    if (element == null) 
380      return;
381    Complex t;
382    if (Utilities.noString(parentType))
383      t = parent;
384    else {
385      t = parent.predicate("fhir:"+parentType+'.'+name);
386    }
387    composeDataType(t, "CodeableReference", name, element, index);
388    if (element.hasConcept()) {
389      composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1);
390    }
391    if (element.hasReference()) {
392      composeReference(t, "CodeableReference", "reference", element.getReference(), -1);
393    }
394  }
395
396  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
397    if (element == null) 
398      return;
399    Complex t;
400    if (Utilities.noString(parentType))
401      t = parent;
402    else {
403      t = parent.predicate("fhir:"+parentType+'.'+name);
404    }
405    composeDataType(t, "Coding", name, element, index);
406    decorateCoding(t, element);
407    if (element.hasSystemElement()) {
408      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
409    }
410    if (element.hasVersionElement()) {
411      composeString(t, "Coding", "version", element.getVersionElement(), -1);
412    }
413    if (element.hasCodeElement()) {
414      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
415    }
416    if (element.hasDisplayElement()) {
417      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
418    }
419    if (element.hasUserSelectedElement()) {
420      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
421    }
422  }
423
424  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail 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:"+parentType+'.'+name);
432    }
433    composeDataType(t, "ContactDetail", name, element, index);
434    if (element.hasNameElement()) {
435      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
436    }
437    for (int i = 0; i < element.getTelecom().size(); i++) {
438      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
439    }
440  }
441
442  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint 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:"+parentType+'.'+name);
450    }
451    composeDataType(t, "ContactPoint", name, element, index);
452    if (element.hasSystemElement()) {
453      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
454    }
455    if (element.hasValueElement()) {
456      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
457    }
458    if (element.hasUseElement()) {
459      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
460    }
461    if (element.hasRankElement()) {
462      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
463    }
464    if (element.hasPeriod()) {
465      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
466    }
467  }
468
469  protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) {
470    if (element == null) 
471      return;
472    Complex t;
473    if (Utilities.noString(parentType))
474      t = parent;
475    else {
476      t = parent.predicate("fhir:"+parentType+'.'+name);
477    }
478    composeDataType(t, "Contributor", name, element, index);
479    if (element.hasTypeElement()) {
480      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
481    }
482    if (element.hasNameElement()) {
483      composeString(t, "Contributor", "name", element.getNameElement(), -1);
484    }
485    for (int i = 0; i < element.getContact().size(); i++) {
486      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
487    }
488  }
489
490  protected void composeCount(Complex parent, String parentType, String name, Count element, int index) {
491    if (element == null) 
492      return;
493    Complex t;
494    if (Utilities.noString(parentType))
495      t = parent;
496    else {
497      t = parent.predicate("fhir:"+parentType+'.'+name);
498    }
499    composeQuantity(t, "Count", name, element, index);
500  }
501
502  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) {
503    if (element == null) 
504      return;
505    Complex t;
506    if (Utilities.noString(parentType))
507      t = parent;
508    else {
509      t = parent.predicate("fhir:"+parentType+'.'+name);
510    }
511    composeDataType(t, "DataRequirement", name, element, index);
512    if (element.hasTypeElement()) {
513      composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1);
514    }
515    for (int i = 0; i < element.getProfile().size(); i++) {
516      composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i);
517    }
518    if (element.hasSubject()) {
519      composeType(t, "DataRequirement", "subject", element.getSubject(), -1);
520    }
521    for (int i = 0; i < element.getMustSupport().size(); i++) {
522      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
523    }
524    for (int i = 0; i < element.getCodeFilter().size(); i++) {
525      composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
526    }
527    for (int i = 0; i < element.getDateFilter().size(); i++) {
528      composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
529    }
530    if (element.hasLimitElement()) {
531      composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1);
532    }
533    for (int i = 0; i < element.getSort().size(); i++) {
534      composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i);
535    }
536  }
537
538  protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
539    if (element == null) 
540      return;
541    Complex t;
542    if (Utilities.noString(parentType))
543      t = parent;
544    else {
545      t = parent.predicate("fhir:"+parentType+'.'+name);
546    }
547    composeElement(t, "codeFilter", name, element, index);
548    if (element.hasPathElement()) {
549      composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1);
550    }
551    if (element.hasSearchParamElement()) {
552      composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1);
553    }
554    if (element.hasValueSetElement()) {
555      composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1);
556    }
557    for (int i = 0; i < element.getCode().size(); i++) {
558      composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i);
559    }
560  }
561
562  protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
563    if (element == null) 
564      return;
565    Complex t;
566    if (Utilities.noString(parentType))
567      t = parent;
568    else {
569      t = parent.predicate("fhir:"+parentType+'.'+name);
570    }
571    composeElement(t, "dateFilter", name, element, index);
572    if (element.hasPathElement()) {
573      composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1);
574    }
575    if (element.hasSearchParamElement()) {
576      composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1);
577    }
578    if (element.hasValue()) {
579      composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1);
580    }
581  }
582
583  protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) {
584    if (element == null) 
585      return;
586    Complex t;
587    if (Utilities.noString(parentType))
588      t = parent;
589    else {
590      t = parent.predicate("fhir:"+parentType+'.'+name);
591    }
592    composeElement(t, "sort", name, element, index);
593    if (element.hasPathElement()) {
594      composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1);
595    }
596    if (element.hasDirectionElement()) {
597      composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1);
598    }
599  }
600
601  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
602    if (element == null) 
603      return;
604    Complex t;
605    if (Utilities.noString(parentType))
606      t = parent;
607    else {
608      t = parent.predicate("fhir:"+parentType+'.'+name);
609    }
610    composeQuantity(t, "Distance", name, element, index);
611  }
612
613  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
614    if (element == null) 
615      return;
616    Complex t;
617    if (Utilities.noString(parentType))
618      t = parent;
619    else {
620      t = parent.predicate("fhir:"+parentType+'.'+name);
621    }
622    composeDataType(t, "Dosage", name, element, index);
623    if (element.hasSequenceElement()) {
624      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
625    }
626    if (element.hasTextElement()) {
627      composeString(t, "Dosage", "text", element.getTextElement(), -1);
628    }
629    for (int i = 0; i < element.getAdditionalInstruction().size(); i++) {
630      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
631    }
632    if (element.hasPatientInstructionElement()) {
633      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
634    }
635    if (element.hasTiming()) {
636      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
637    }
638    if (element.hasAsNeeded()) {
639      composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1);
640    }
641    if (element.hasSite()) {
642      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
643    }
644    if (element.hasRoute()) {
645      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
646    }
647    if (element.hasMethod()) {
648      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
649    }
650    for (int i = 0; i < element.getDoseAndRate().size(); i++) {
651      composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i);
652    }
653    if (element.hasMaxDosePerPeriod()) {
654      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1);
655    }
656    if (element.hasMaxDosePerAdministration()) {
657      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
658    }
659    if (element.hasMaxDosePerLifetime()) {
660      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
661    }
662  }
663
664  protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) {
665    if (element == null) 
666      return;
667    Complex t;
668    if (Utilities.noString(parentType))
669      t = parent;
670    else {
671      t = parent.predicate("fhir:"+parentType+'.'+name);
672    }
673    composeElement(t, "doseAndRate", name, element, index);
674    if (element.hasType()) {
675      composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1);
676    }
677    if (element.hasDose()) {
678      composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1);
679    }
680    if (element.hasRate()) {
681      composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1);
682    }
683  }
684
685  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
686    if (element == null) 
687      return;
688    Complex t;
689    if (Utilities.noString(parentType))
690      t = parent;
691    else {
692      t = parent.predicate("fhir:"+parentType+'.'+name);
693    }
694    composeQuantity(t, "Duration", name, element, index);
695  }
696
697  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
698    if (element == null) 
699      return;
700    Complex t;
701    if (Utilities.noString(parentType))
702      t = parent;
703    else {
704      t = parent.predicate("fhir:"+parentType+'.'+name);
705    }
706    composeDataType(t, "ElementDefinition", name, element, index);
707    if (element.hasPathElement()) {
708      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
709    }
710    for (int i = 0; i < element.getRepresentation().size(); i++) {
711      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
712    }
713    if (element.hasSliceNameElement()) {
714      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
715    }
716    if (element.hasSliceIsConstrainingElement()) {
717      composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1);
718    }
719    if (element.hasLabelElement()) {
720      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
721    }
722    for (int i = 0; i < element.getCode().size(); i++) {
723      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
724    }
725    if (element.hasSlicing()) {
726      composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
727    }
728    if (element.hasShortElement()) {
729      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
730    }
731    if (element.hasDefinitionElement()) {
732      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
733    }
734    if (element.hasCommentElement()) {
735      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
736    }
737    if (element.hasRequirementsElement()) {
738      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
739    }
740    for (int i = 0; i < element.getAlias().size(); i++) {
741      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
742    }
743    if (element.hasMinElement()) {
744      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
745    }
746    if (element.hasMaxElement()) {
747      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
748    }
749    if (element.hasBase()) {
750      composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
751    }
752    if (element.hasContentReferenceElement()) {
753      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
754    }
755    for (int i = 0; i < element.getType().size(); i++) {
756      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
757    }
758    if (element.hasDefaultValue()) {
759      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
760    }
761    if (element.hasMeaningWhenMissingElement()) {
762      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
763    }
764    if (element.hasOrderMeaningElement()) {
765      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
766    }
767    if (element.hasFixed()) {
768      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
769    }
770    if (element.hasPattern()) {
771      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
772    }
773    for (int i = 0; i < element.getExample().size(); i++) {
774      composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
775    }
776    if (element.hasMinValue()) {
777      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
778    }
779    if (element.hasMaxValue()) {
780      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
781    }
782    if (element.hasMaxLengthElement()) {
783      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
784    }
785    for (int i = 0; i < element.getCondition().size(); i++) {
786      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
787    }
788    for (int i = 0; i < element.getConstraint().size(); i++) {
789      composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
790    }
791    if (element.hasMustSupportElement()) {
792      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
793    }
794    if (element.hasIsModifierElement()) {
795      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
796    }
797    if (element.hasIsModifierReasonElement()) {
798      composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1);
799    }
800    if (element.hasIsSummaryElement()) {
801      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
802    }
803    if (element.hasBinding()) {
804      composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
805    }
806    for (int i = 0; i < element.getMapping().size(); i++) {
807      composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
808    }
809  }
810
811  protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) {
812    if (element == null) 
813      return;
814    Complex t;
815    if (Utilities.noString(parentType))
816      t = parent;
817    else {
818      t = parent.predicate("fhir:"+parentType+'.'+name);
819    }
820    composeElement(t, "slicing", name, element, index);
821    for (int i = 0; i < element.getDiscriminator().size(); i++) {
822      composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i);
823    }
824    if (element.hasDescriptionElement()) {
825      composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1);
826    }
827    if (element.hasOrderedElement()) {
828      composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1);
829    }
830    if (element.hasRulesElement()) {
831      composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1);
832    }
833  }
834
835  protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
836    if (element == null) 
837      return;
838    Complex t;
839    if (Utilities.noString(parentType))
840      t = parent;
841    else {
842      t = parent.predicate("fhir:"+parentType+'.'+name);
843    }
844    composeElement(t, "discriminator", name, element, index);
845    if (element.hasTypeElement()) {
846      composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1);
847    }
848    if (element.hasPathElement()) {
849      composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1);
850    }
851  }
852
853  protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
854    if (element == null) 
855      return;
856    Complex t;
857    if (Utilities.noString(parentType))
858      t = parent;
859    else {
860      t = parent.predicate("fhir:"+parentType+'.'+name);
861    }
862    composeElement(t, "base", name, element, index);
863    if (element.hasPathElement()) {
864      composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1);
865    }
866    if (element.hasMinElement()) {
867      composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1);
868    }
869    if (element.hasMaxElement()) {
870      composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1);
871    }
872  }
873
874  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
875    if (element == null) 
876      return;
877    Complex t;
878    if (Utilities.noString(parentType))
879      t = parent;
880    else {
881      t = parent.predicate("fhir:"+parentType+'.'+name);
882    }
883    composeElement(t, "type", name, element, index);
884    if (element.hasCodeElement()) {
885      composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1);
886    }
887    for (int i = 0; i < element.getProfile().size(); i++) {
888      composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i);
889    }
890    for (int i = 0; i < element.getTargetProfile().size(); i++) {
891      composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i);
892    }
893    for (int i = 0; i < element.getAggregation().size(); i++) {
894      composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i);
895    }
896    if (element.hasVersioningElement()) {
897      composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1);
898    }
899  }
900
901  protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
902    if (element == null) 
903      return;
904    Complex t;
905    if (Utilities.noString(parentType))
906      t = parent;
907    else {
908      t = parent.predicate("fhir:"+parentType+'.'+name);
909    }
910    composeElement(t, "example", name, element, index);
911    if (element.hasLabelElement()) {
912      composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1);
913    }
914    if (element.hasValue()) {
915      composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1);
916    }
917  }
918
919  protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
920    if (element == null) 
921      return;
922    Complex t;
923    if (Utilities.noString(parentType))
924      t = parent;
925    else {
926      t = parent.predicate("fhir:"+parentType+'.'+name);
927    }
928    composeElement(t, "constraint", name, element, index);
929    if (element.hasKeyElement()) {
930      composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1);
931    }
932    if (element.hasRequirementsElement()) {
933      composeString(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1);
934    }
935    if (element.hasSeverityElement()) {
936      composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1);
937    }
938    if (element.hasHumanElement()) {
939      composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1);
940    }
941    if (element.hasExpressionElement()) {
942      composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1);
943    }
944    if (element.hasXpathElement()) {
945      composeString(t, "ElementDefinitionConstraintComponent", "xpath", element.getXpathElement(), -1);
946    }
947    if (element.hasSourceElement()) {
948      composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1);
949    }
950  }
951
952  protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
953    if (element == null) 
954      return;
955    Complex t;
956    if (Utilities.noString(parentType))
957      t = parent;
958    else {
959      t = parent.predicate("fhir:"+parentType+'.'+name);
960    }
961    composeElement(t, "binding", name, element, index);
962    if (element.hasStrengthElement()) {
963      composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1);
964    }
965    if (element.hasDescriptionElement()) {
966      composeString(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1);
967    }
968    if (element.hasValueSetElement()) {
969      composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1);
970    }
971  }
972
973  protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
974    if (element == null) 
975      return;
976    Complex t;
977    if (Utilities.noString(parentType))
978      t = parent;
979    else {
980      t = parent.predicate("fhir:"+parentType+'.'+name);
981    }
982    composeElement(t, "mapping", name, element, index);
983    if (element.hasIdentityElement()) {
984      composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
985    }
986    if (element.hasLanguageElement()) {
987      composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1);
988    }
989    if (element.hasMapElement()) {
990      composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1);
991    }
992    if (element.hasCommentElement()) {
993      composeString(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
994    }
995  }
996
997  protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) {
998    if (element == null) 
999      return;
1000    Complex t;
1001    if (Utilities.noString(parentType))
1002      t = parent;
1003    else {
1004      t = parent.predicate("fhir:"+parentType+'.'+name);
1005    }
1006    composeDataType(t, "Expression", name, element, index);
1007    if (element.hasDescriptionElement()) {
1008      composeString(t, "Expression", "description", element.getDescriptionElement(), -1);
1009    }
1010    if (element.hasNameElement()) {
1011      composeId(t, "Expression", "name", element.getNameElement(), -1);
1012    }
1013    if (element.hasLanguageElement()) {
1014      composeCode(t, "Expression", "language", element.getLanguageElement(), -1);
1015    }
1016    if (element.hasExpressionElement()) {
1017      composeString(t, "Expression", "expression", element.getExpressionElement(), -1);
1018    }
1019    if (element.hasReferenceElement()) {
1020      composeUri(t, "Expression", "reference", element.getReferenceElement(), -1);
1021    }
1022  }
1023
1024  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
1025    if (element == null) 
1026      return;
1027    Complex t;
1028    if (Utilities.noString(parentType))
1029      t = parent;
1030    else {
1031      t = parent.predicate("fhir:"+parentType+'.'+name);
1032    }
1033    composeDataType(t, "Extension", name, element, index);
1034    if (element.hasUrlElement()) {
1035      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
1036    }
1037    if (element.hasValue()) {
1038      composeType(t, "Extension", "value", element.getValue(), -1);
1039    }
1040  }
1041
1042  protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) {
1043    if (element == null) 
1044      return;
1045    Complex t;
1046    if (Utilities.noString(parentType))
1047      t = parent;
1048    else {
1049      t = parent.predicate("fhir:"+parentType+'.'+name);
1050    }
1051    composeDataType(t, "HumanName", name, element, index);
1052    if (element.hasUseElement()) {
1053      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
1054    }
1055    if (element.hasTextElement()) {
1056      composeString(t, "HumanName", "text", element.getTextElement(), -1);
1057    }
1058    if (element.hasFamilyElement()) {
1059      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
1060    }
1061    for (int i = 0; i < element.getGiven().size(); i++) {
1062      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
1063    }
1064    for (int i = 0; i < element.getPrefix().size(); i++) {
1065      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
1066    }
1067    for (int i = 0; i < element.getSuffix().size(); i++) {
1068      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
1069    }
1070    if (element.hasPeriod()) {
1071      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
1072    }
1073  }
1074
1075  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
1076    if (element == null) 
1077      return;
1078    Complex t;
1079    if (Utilities.noString(parentType))
1080      t = parent;
1081    else {
1082      t = parent.predicate("fhir:"+parentType+'.'+name);
1083    }
1084    composeDataType(t, "Identifier", name, element, index);
1085    if (element.hasUseElement()) {
1086      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
1087    }
1088    if (element.hasType()) {
1089      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
1090    }
1091    if (element.hasSystemElement()) {
1092      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
1093    }
1094    if (element.hasValueElement()) {
1095      composeString(t, "Identifier", "value", element.getValueElement(), -1);
1096    }
1097    if (element.hasPeriod()) {
1098      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
1099    }
1100    if (element.hasAssigner()) {
1101      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
1102    }
1103  }
1104
1105  protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) {
1106    if (element == null) 
1107      return;
1108    Complex t;
1109    if (Utilities.noString(parentType))
1110      t = parent;
1111    else {
1112      t = parent.predicate("fhir:"+parentType+'.'+name);
1113    }
1114    composeDataType(t, "MarketingStatus", name, element, index);
1115    if (element.hasCountry()) {
1116      composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1);
1117    }
1118    if (element.hasJurisdiction()) {
1119      composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1);
1120    }
1121    if (element.hasStatus()) {
1122      composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1);
1123    }
1124    if (element.hasDateRange()) {
1125      composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1);
1126    }
1127    if (element.hasRestoreDateElement()) {
1128      composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1);
1129    }
1130  }
1131
1132  protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) {
1133    if (element == null) 
1134      return;
1135    Complex t;
1136    if (Utilities.noString(parentType))
1137      t = parent;
1138    else {
1139      t = parent.predicate("fhir:"+parentType+'.'+name);
1140    }
1141    composeDataType(t, "Meta", name, element, index);
1142    if (element.hasVersionIdElement()) {
1143      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
1144    }
1145    if (element.hasLastUpdatedElement()) {
1146      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
1147    }
1148    if (element.hasSourceElement()) {
1149      composeUri(t, "Meta", "source", element.getSourceElement(), -1);
1150    }
1151    for (int i = 0; i < element.getProfile().size(); i++) {
1152      composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i);
1153    }
1154    for (int i = 0; i < element.getSecurity().size(); i++) {
1155      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
1156    }
1157    for (int i = 0; i < element.getTag().size(); i++) {
1158      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
1159    }
1160  }
1161
1162  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
1163    if (element == null) 
1164      return;
1165    Complex t;
1166    if (Utilities.noString(parentType))
1167      t = parent;
1168    else {
1169      t = parent.predicate("fhir:"+parentType+'.'+name);
1170    }
1171    composeDataType(t, "Money", name, element, index);
1172    if (element.hasValueElement()) {
1173      composeDecimal(t, "Money", "value", element.getValueElement(), -1);
1174    }
1175    if (element.hasCurrencyElement()) {
1176      composeCode(t, "Money", "currency", element.getCurrencyElement(), -1);
1177    }
1178  }
1179
1180  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
1181    if (element == null) 
1182      return;
1183    Complex t;
1184    if (Utilities.noString(parentType))
1185      t = parent;
1186    else {
1187      t = parent.predicate("fhir:"+parentType+'.'+name);
1188    }
1189    composeDataType(t, "Narrative", name, element, index);
1190    if (element.hasStatusElement()) {
1191      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
1192    }
1193    if (element.hasDiv()) {
1194      composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1);
1195    }
1196  }
1197
1198  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
1199    if (element == null) 
1200      return;
1201    Complex t;
1202    if (Utilities.noString(parentType))
1203      t = parent;
1204    else {
1205      t = parent.predicate("fhir:"+parentType+'.'+name);
1206    }
1207    composeDataType(t, "ParameterDefinition", name, element, index);
1208    if (element.hasNameElement()) {
1209      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
1210    }
1211    if (element.hasUseElement()) {
1212      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
1213    }
1214    if (element.hasMinElement()) {
1215      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
1216    }
1217    if (element.hasMaxElement()) {
1218      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
1219    }
1220    if (element.hasDocumentationElement()) {
1221      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
1222    }
1223    if (element.hasTypeElement()) {
1224      composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
1225    }
1226    if (element.hasProfileElement()) {
1227      composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1);
1228    }
1229  }
1230
1231  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
1232    if (element == null) 
1233      return;
1234    Complex t;
1235    if (Utilities.noString(parentType))
1236      t = parent;
1237    else {
1238      t = parent.predicate("fhir:"+parentType+'.'+name);
1239    }
1240    composeDataType(t, "Period", name, element, index);
1241    if (element.hasStartElement()) {
1242      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
1243    }
1244    if (element.hasEndElement()) {
1245      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
1246    }
1247  }
1248
1249  protected void composePopulation(Complex parent, String parentType, String name, Population element, int index) {
1250    if (element == null) 
1251      return;
1252    Complex t;
1253    if (Utilities.noString(parentType))
1254      t = parent;
1255    else {
1256      t = parent.predicate("fhir:"+parentType+'.'+name);
1257    }
1258    composeDataType(t, "Population", name, element, index);
1259    if (element.hasAge()) {
1260      composeType(t, "Population", "age", element.getAge(), -1);
1261    }
1262    if (element.hasGender()) {
1263      composeCodeableConcept(t, "Population", "gender", element.getGender(), -1);
1264    }
1265    if (element.hasRace()) {
1266      composeCodeableConcept(t, "Population", "race", element.getRace(), -1);
1267    }
1268    if (element.hasPhysiologicalCondition()) {
1269      composeCodeableConcept(t, "Population", "physiologicalCondition", element.getPhysiologicalCondition(), -1);
1270    }
1271  }
1272
1273  protected void composeProdCharacteristic(Complex parent, String parentType, String name, ProdCharacteristic element, int index) {
1274    if (element == null) 
1275      return;
1276    Complex t;
1277    if (Utilities.noString(parentType))
1278      t = parent;
1279    else {
1280      t = parent.predicate("fhir:"+parentType+'.'+name);
1281    }
1282    composeDataType(t, "ProdCharacteristic", name, element, index);
1283    if (element.hasHeight()) {
1284      composeQuantity(t, "ProdCharacteristic", "height", element.getHeight(), -1);
1285    }
1286    if (element.hasWidth()) {
1287      composeQuantity(t, "ProdCharacteristic", "width", element.getWidth(), -1);
1288    }
1289    if (element.hasDepth()) {
1290      composeQuantity(t, "ProdCharacteristic", "depth", element.getDepth(), -1);
1291    }
1292    if (element.hasWeight()) {
1293      composeQuantity(t, "ProdCharacteristic", "weight", element.getWeight(), -1);
1294    }
1295    if (element.hasNominalVolume()) {
1296      composeQuantity(t, "ProdCharacteristic", "nominalVolume", element.getNominalVolume(), -1);
1297    }
1298    if (element.hasExternalDiameter()) {
1299      composeQuantity(t, "ProdCharacteristic", "externalDiameter", element.getExternalDiameter(), -1);
1300    }
1301    if (element.hasShapeElement()) {
1302      composeString(t, "ProdCharacteristic", "shape", element.getShapeElement(), -1);
1303    }
1304    for (int i = 0; i < element.getColor().size(); i++) {
1305      composeString(t, "ProdCharacteristic", "color", element.getColor().get(i), i);
1306    }
1307    for (int i = 0; i < element.getImprint().size(); i++) {
1308      composeString(t, "ProdCharacteristic", "imprint", element.getImprint().get(i), i);
1309    }
1310    for (int i = 0; i < element.getImage().size(); i++) {
1311      composeAttachment(t, "ProdCharacteristic", "image", element.getImage().get(i), i);
1312    }
1313    if (element.hasScoring()) {
1314      composeCodeableConcept(t, "ProdCharacteristic", "scoring", element.getScoring(), -1);
1315    }
1316  }
1317
1318  protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) {
1319    if (element == null) 
1320      return;
1321    Complex t;
1322    if (Utilities.noString(parentType))
1323      t = parent;
1324    else {
1325      t = parent.predicate("fhir:"+parentType+'.'+name);
1326    }
1327    composeDataType(t, "ProductShelfLife", name, element, index);
1328    if (element.hasType()) {
1329      composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1);
1330    }
1331    if (element.hasPeriod()) {
1332      composeType(t, "ProductShelfLife", "period", element.getPeriod(), -1);
1333    }
1334    for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) {
1335      composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i);
1336    }
1337  }
1338
1339  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
1340    if (element == null) 
1341      return;
1342    Complex t;
1343    if (Utilities.noString(parentType))
1344      t = parent;
1345    else {
1346      t = parent.predicate("fhir:"+parentType+'.'+name);
1347    }
1348    composeDataType(t, "Quantity", name, element, index);
1349    if (element.hasValueElement()) {
1350      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
1351    }
1352    if (element.hasComparatorElement()) {
1353      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
1354    }
1355    if (element.hasUnitElement()) {
1356      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
1357    }
1358    if (element.hasSystemElement()) {
1359      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
1360    }
1361    if (element.hasCodeElement()) {
1362      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
1363    }
1364  }
1365
1366  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
1367    if (element == null) 
1368      return;
1369    Complex t;
1370    if (Utilities.noString(parentType))
1371      t = parent;
1372    else {
1373      t = parent.predicate("fhir:"+parentType+'.'+name);
1374    }
1375    composeDataType(t, "Range", name, element, index);
1376    if (element.hasLow()) {
1377      composeQuantity(t, "Range", "low", element.getLow(), -1);
1378    }
1379    if (element.hasHigh()) {
1380      composeQuantity(t, "Range", "high", element.getHigh(), -1);
1381    }
1382  }
1383
1384  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
1385    if (element == null) 
1386      return;
1387    Complex t;
1388    if (Utilities.noString(parentType))
1389      t = parent;
1390    else {
1391      t = parent.predicate("fhir:"+parentType+'.'+name);
1392    }
1393    composeDataType(t, "Ratio", name, element, index);
1394    if (element.hasNumerator()) {
1395      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
1396    }
1397    if (element.hasDenominator()) {
1398      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
1399    }
1400  }
1401
1402  protected void composeRatioRange(Complex parent, String parentType, String name, RatioRange element, int index) {
1403    if (element == null) 
1404      return;
1405    Complex t;
1406    if (Utilities.noString(parentType))
1407      t = parent;
1408    else {
1409      t = parent.predicate("fhir:"+parentType+'.'+name);
1410    }
1411    composeDataType(t, "RatioRange", name, element, index);
1412    if (element.hasLowNumerator()) {
1413      composeQuantity(t, "RatioRange", "lowNumerator", element.getLowNumerator(), -1);
1414    }
1415    if (element.hasHighNumerator()) {
1416      composeQuantity(t, "RatioRange", "highNumerator", element.getHighNumerator(), -1);
1417    }
1418    if (element.hasDenominator()) {
1419      composeQuantity(t, "RatioRange", "denominator", element.getDenominator(), -1);
1420    }
1421  }
1422
1423  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
1424    if (element == null) 
1425      return;
1426    Complex t;
1427    if (Utilities.noString(parentType))
1428      t = parent;
1429    else {
1430      t = parent.predicate("fhir:"+parentType+'.'+name);
1431    }
1432    composeDataType(t, "Reference", name, element, index);
1433    if (element.hasReferenceElement()) {
1434      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
1435    }
1436    if (element.hasTypeElement()) {
1437      composeUri(t, "Reference", "type", element.getTypeElement(), -1);
1438    }
1439    if (element.hasIdentifier()) {
1440      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
1441    }
1442    if (element.hasDisplayElement()) {
1443      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
1444    }
1445  }
1446
1447  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
1448    if (element == null) 
1449      return;
1450    Complex t;
1451    if (Utilities.noString(parentType))
1452      t = parent;
1453    else {
1454      t = parent.predicate("fhir:"+parentType+'.'+name);
1455    }
1456    composeDataType(t, "RelatedArtifact", name, element, index);
1457    if (element.hasTypeElement()) {
1458      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
1459    }
1460    if (element.hasLabelElement()) {
1461      composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1);
1462    }
1463    if (element.hasDisplayElement()) {
1464      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
1465    }
1466    if (element.hasCitationElement()) {
1467      composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
1468    }
1469    if (element.hasUrlElement()) {
1470      composeUrl(t, "RelatedArtifact", "url", element.getUrlElement(), -1);
1471    }
1472    if (element.hasDocument()) {
1473      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
1474    }
1475    if (element.hasResourceElement()) {
1476      composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1);
1477    }
1478  }
1479
1480  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
1481    if (element == null) 
1482      return;
1483    Complex t;
1484    if (Utilities.noString(parentType))
1485      t = parent;
1486    else {
1487      t = parent.predicate("fhir:"+parentType+'.'+name);
1488    }
1489    composeDataType(t, "SampledData", name, element, index);
1490    if (element.hasOrigin()) {
1491      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
1492    }
1493    if (element.hasPeriodElement()) {
1494      composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1);
1495    }
1496    if (element.hasFactorElement()) {
1497      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
1498    }
1499    if (element.hasLowerLimitElement()) {
1500      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
1501    }
1502    if (element.hasUpperLimitElement()) {
1503      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
1504    }
1505    if (element.hasDimensionsElement()) {
1506      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
1507    }
1508    if (element.hasDataElement()) {
1509      composeString(t, "SampledData", "data", element.getDataElement(), -1);
1510    }
1511  }
1512
1513  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
1514    if (element == null) 
1515      return;
1516    Complex t;
1517    if (Utilities.noString(parentType))
1518      t = parent;
1519    else {
1520      t = parent.predicate("fhir:"+parentType+'.'+name);
1521    }
1522    composeDataType(t, "Signature", name, element, index);
1523    for (int i = 0; i < element.getType().size(); i++) {
1524      composeCoding(t, "Signature", "type", element.getType().get(i), i);
1525    }
1526    if (element.hasWhenElement()) {
1527      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
1528    }
1529    if (element.hasWho()) {
1530      composeReference(t, "Signature", "who", element.getWho(), -1);
1531    }
1532    if (element.hasOnBehalfOf()) {
1533      composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
1534    }
1535    if (element.hasTargetFormatElement()) {
1536      composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1);
1537    }
1538    if (element.hasSigFormatElement()) {
1539      composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1);
1540    }
1541    if (element.hasDataElement()) {
1542      composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1);
1543    }
1544  }
1545
1546  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
1547    if (element == null) 
1548      return;
1549    Complex t;
1550    if (Utilities.noString(parentType))
1551      t = parent;
1552    else {
1553      t = parent.predicate("fhir:"+parentType+'.'+name);
1554    }
1555    composeDataType(t, "Timing", name, element, index);
1556    for (int i = 0; i < element.getEvent().size(); i++) {
1557      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
1558    }
1559    if (element.hasRepeat()) {
1560      composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
1561    }
1562    if (element.hasCode()) {
1563      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
1564    }
1565  }
1566
1567  protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
1568    if (element == null) 
1569      return;
1570    Complex t;
1571    if (Utilities.noString(parentType))
1572      t = parent;
1573    else {
1574      t = parent.predicate("fhir:"+parentType+'.'+name);
1575    }
1576    composeElement(t, "repeat", name, element, index);
1577    if (element.hasBounds()) {
1578      composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1);
1579    }
1580    if (element.hasCountElement()) {
1581      composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1);
1582    }
1583    if (element.hasCountMaxElement()) {
1584      composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1);
1585    }
1586    if (element.hasDurationElement()) {
1587      composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1);
1588    }
1589    if (element.hasDurationMaxElement()) {
1590      composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1);
1591    }
1592    if (element.hasDurationUnitElement()) {
1593      composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1);
1594    }
1595    if (element.hasFrequencyElement()) {
1596      composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1);
1597    }
1598    if (element.hasFrequencyMaxElement()) {
1599      composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1);
1600    }
1601    if (element.hasPeriodElement()) {
1602      composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1);
1603    }
1604    if (element.hasPeriodMaxElement()) {
1605      composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1);
1606    }
1607    if (element.hasPeriodUnitElement()) {
1608      composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1);
1609    }
1610    for (int i = 0; i < element.getDayOfWeek().size(); i++) {
1611      composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i);
1612    }
1613    for (int i = 0; i < element.getTimeOfDay().size(); i++) {
1614      composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i);
1615    }
1616    for (int i = 0; i < element.getWhen().size(); i++) {
1617      composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i);
1618    }
1619    if (element.hasOffsetElement()) {
1620      composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1);
1621    }
1622  }
1623
1624  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
1625    if (element == null) 
1626      return;
1627    Complex t;
1628    if (Utilities.noString(parentType))
1629      t = parent;
1630    else {
1631      t = parent.predicate("fhir:"+parentType+'.'+name);
1632    }
1633    composeDataType(t, "TriggerDefinition", name, element, index);
1634    if (element.hasTypeElement()) {
1635      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
1636    }
1637    if (element.hasNameElement()) {
1638      composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1);
1639    }
1640    if (element.hasTiming()) {
1641      composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1);
1642    }
1643    for (int i = 0; i < element.getData().size(); i++) {
1644      composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i);
1645    }
1646    if (element.hasCondition()) {
1647      composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1);
1648    }
1649  }
1650
1651  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
1652    if (element == null) 
1653      return;
1654    Complex t;
1655    if (Utilities.noString(parentType))
1656      t = parent;
1657    else {
1658      t = parent.predicate("fhir:"+parentType+'.'+name);
1659    }
1660    composeDataType(t, "UsageContext", name, element, index);
1661    if (element.hasCode()) {
1662      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
1663    }
1664    if (element.hasValue()) {
1665      composeType(t, "UsageContext", "value", element.getValue(), -1);
1666    }
1667  }
1668
1669  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
1670    if (element.hasIdElement()) {
1671      composeId(t, "Resource", "id", element.getIdElement(), -1);
1672    }
1673    if (element.hasMeta()) {
1674      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
1675    }
1676    if (element.hasImplicitRulesElement()) {
1677      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
1678    }
1679    if (element.hasLanguageElement()) {
1680      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
1681    }
1682  }
1683
1684  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
1685    composeResource(t, parentType, name, element, index);
1686    if (element.hasText()) {
1687      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
1688    }
1689    for (int i = 0; i < element.getContained().size(); i++) {
1690      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
1691    }
1692    for (int i = 0; i < element.getExtension().size(); i++) {
1693      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
1694    }
1695    for (int i = 0; i < element.getModifierExtension().size(); i++) {
1696      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
1697    }
1698  }
1699
1700  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
1701    if (element == null) 
1702      return;
1703    Complex t;
1704    if (Utilities.noString(parentType))
1705      t = parent;
1706    else {
1707      t = parent.predicate("fhir:"+parentType+'.'+name);
1708    }
1709    composeDomainResource(t, "Account", name, element, index);
1710    for (int i = 0; i < element.getIdentifier().size(); i++) {
1711      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
1712    }
1713    if (element.hasStatusElement()) {
1714      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
1715    }
1716    if (element.hasType()) {
1717      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
1718    }
1719    if (element.hasNameElement()) {
1720      composeString(t, "Account", "name", element.getNameElement(), -1);
1721    }
1722    for (int i = 0; i < element.getSubject().size(); i++) {
1723      composeReference(t, "Account", "subject", element.getSubject().get(i), i);
1724    }
1725    if (element.hasServicePeriod()) {
1726      composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1);
1727    }
1728    for (int i = 0; i < element.getCoverage().size(); i++) {
1729      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
1730    }
1731    if (element.hasOwner()) {
1732      composeReference(t, "Account", "owner", element.getOwner(), -1);
1733    }
1734    if (element.hasDescriptionElement()) {
1735      composeString(t, "Account", "description", element.getDescriptionElement(), -1);
1736    }
1737    for (int i = 0; i < element.getGuarantor().size(); i++) {
1738      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
1739    }
1740    if (element.hasPartOf()) {
1741      composeReference(t, "Account", "partOf", element.getPartOf(), -1);
1742    }
1743  }
1744
1745  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
1746    if (element == null) 
1747      return;
1748    Complex t;
1749    if (Utilities.noString(parentType))
1750      t = parent;
1751    else {
1752      t = parent.predicate("fhir:"+parentType+'.'+name);
1753    }
1754    composeBackboneElement(t, "coverage", name, element, index);
1755    if (element.hasCoverage()) {
1756      composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1);
1757    }
1758    if (element.hasPriorityElement()) {
1759      composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1);
1760    }
1761  }
1762
1763  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
1764    if (element == null) 
1765      return;
1766    Complex t;
1767    if (Utilities.noString(parentType))
1768      t = parent;
1769    else {
1770      t = parent.predicate("fhir:"+parentType+'.'+name);
1771    }
1772    composeBackboneElement(t, "guarantor", name, element, index);
1773    if (element.hasParty()) {
1774      composeReference(t, "GuarantorComponent", "party", element.getParty(), -1);
1775    }
1776    if (element.hasOnHoldElement()) {
1777      composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1);
1778    }
1779    if (element.hasPeriod()) {
1780      composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1);
1781    }
1782  }
1783
1784  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) {
1785    if (element == null) 
1786      return;
1787    Complex t;
1788    if (Utilities.noString(parentType))
1789      t = parent;
1790    else {
1791      t = parent.predicate("fhir:"+parentType+'.'+name);
1792    }
1793    composeDomainResource(t, "ActivityDefinition", name, element, index);
1794    if (element.hasUrlElement()) {
1795      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
1796    }
1797    for (int i = 0; i < element.getIdentifier().size(); i++) {
1798      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
1799    }
1800    if (element.hasVersionElement()) {
1801      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
1802    }
1803    if (element.hasNameElement()) {
1804      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
1805    }
1806    if (element.hasTitleElement()) {
1807      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
1808    }
1809    if (element.hasSubtitleElement()) {
1810      composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1);
1811    }
1812    if (element.hasStatusElement()) {
1813      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
1814    }
1815    if (element.hasExperimentalElement()) {
1816      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
1817    }
1818    if (element.hasSubject()) {
1819      composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1);
1820    }
1821    if (element.hasDateElement()) {
1822      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
1823    }
1824    if (element.hasPublisherElement()) {
1825      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
1826    }
1827    for (int i = 0; i < element.getContact().size(); i++) {
1828      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
1829    }
1830    if (element.hasDescriptionElement()) {
1831      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
1832    }
1833    for (int i = 0; i < element.getUseContext().size(); i++) {
1834      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
1835    }
1836    for (int i = 0; i < element.getJurisdiction().size(); i++) {
1837      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
1838    }
1839    if (element.hasPurposeElement()) {
1840      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
1841    }
1842    if (element.hasUsageElement()) {
1843      composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
1844    }
1845    if (element.hasCopyrightElement()) {
1846      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
1847    }
1848    if (element.hasApprovalDateElement()) {
1849      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
1850    }
1851    if (element.hasLastReviewDateElement()) {
1852      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
1853    }
1854    if (element.hasEffectivePeriod()) {
1855      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
1856    }
1857    for (int i = 0; i < element.getTopic().size(); i++) {
1858      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
1859    }
1860    for (int i = 0; i < element.getAuthor().size(); i++) {
1861      composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i);
1862    }
1863    for (int i = 0; i < element.getEditor().size(); i++) {
1864      composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i);
1865    }
1866    for (int i = 0; i < element.getReviewer().size(); i++) {
1867      composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i);
1868    }
1869    for (int i = 0; i < element.getEndorser().size(); i++) {
1870      composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i);
1871    }
1872    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
1873      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
1874    }
1875    for (int i = 0; i < element.getLibrary().size(); i++) {
1876      composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
1877    }
1878    if (element.hasKindElement()) {
1879      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
1880    }
1881    if (element.hasProfileElement()) {
1882      composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1);
1883    }
1884    if (element.hasCode()) {
1885      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
1886    }
1887    if (element.hasIntentElement()) {
1888      composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1);
1889    }
1890    if (element.hasPriorityElement()) {
1891      composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1);
1892    }
1893    if (element.hasDoNotPerformElement()) {
1894      composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1);
1895    }
1896    if (element.hasTiming()) {
1897      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
1898    }
1899    if (element.hasLocation()) {
1900      composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
1901    }
1902    for (int i = 0; i < element.getParticipant().size(); i++) {
1903      composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
1904    }
1905    if (element.hasProduct()) {
1906      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
1907    }
1908    if (element.hasQuantity()) {
1909      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
1910    }
1911    for (int i = 0; i < element.getDosage().size(); i++) {
1912      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
1913    }
1914    for (int i = 0; i < element.getBodySite().size(); i++) {
1915      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
1916    }
1917    for (int i = 0; i < element.getSpecimenRequirement().size(); i++) {
1918      composeReference(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i);
1919    }
1920    for (int i = 0; i < element.getObservationRequirement().size(); i++) {
1921      composeReference(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i);
1922    }
1923    for (int i = 0; i < element.getObservationResultRequirement().size(); i++) {
1924      composeReference(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i);
1925    }
1926    if (element.hasTransformElement()) {
1927      composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1);
1928    }
1929    for (int i = 0; i < element.getDynamicValue().size(); i++) {
1930      composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
1931    }
1932  }
1933
1934  protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
1935    if (element == null) 
1936      return;
1937    Complex t;
1938    if (Utilities.noString(parentType))
1939      t = parent;
1940    else {
1941      t = parent.predicate("fhir:"+parentType+'.'+name);
1942    }
1943    composeBackboneElement(t, "participant", name, element, index);
1944    if (element.hasTypeElement()) {
1945      composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1);
1946    }
1947    if (element.hasRole()) {
1948      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1);
1949    }
1950  }
1951
1952  protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
1953    if (element == null) 
1954      return;
1955    Complex t;
1956    if (Utilities.noString(parentType))
1957      t = parent;
1958    else {
1959      t = parent.predicate("fhir:"+parentType+'.'+name);
1960    }
1961    composeBackboneElement(t, "dynamicValue", name, element, index);
1962    if (element.hasPathElement()) {
1963      composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1);
1964    }
1965    if (element.hasExpression()) {
1966      composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1);
1967    }
1968  }
1969
1970  protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) {
1971    if (element == null) 
1972      return;
1973    Complex t;
1974    if (Utilities.noString(parentType))
1975      t = parent;
1976    else {
1977      t = parent.predicate("fhir:"+parentType+'.'+name);
1978    }
1979    composeDomainResource(t, "AdministrableProductDefinition", name, element, index);
1980    for (int i = 0; i < element.getIdentifier().size(); i++) {
1981      composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i);
1982    }
1983    if (element.hasStatusElement()) {
1984      composeEnum(t, "AdministrableProductDefinition", "status", element.getStatusElement(), -1);
1985    }
1986    for (int i = 0; i < element.getFormOf().size(); i++) {
1987      composeReference(t, "AdministrableProductDefinition", "formOf", element.getFormOf().get(i), i);
1988    }
1989    if (element.hasAdministrableDoseForm()) {
1990      composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1);
1991    }
1992    if (element.hasUnitOfPresentation()) {
1993      composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
1994    }
1995    for (int i = 0; i < element.getProducedFrom().size(); i++) {
1996      composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i);
1997    }
1998    for (int i = 0; i < element.getIngredient().size(); i++) {
1999      composeCodeableConcept(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i);
2000    }
2001    if (element.hasDevice()) {
2002      composeReference(t, "AdministrableProductDefinition", "device", element.getDevice(), -1);
2003    }
2004    for (int i = 0; i < element.getProperty().size(); i++) {
2005      composeAdministrableProductDefinitionPropertyComponent(t, "AdministrableProductDefinition", "property", element.getProperty().get(i), i);
2006    }
2007    for (int i = 0; i < element.getRouteOfAdministration().size(); i++) {
2008      composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i);
2009    }
2010  }
2011
2012  protected void composeAdministrableProductDefinitionPropertyComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent element, int index) {
2013    if (element == null) 
2014      return;
2015    Complex t;
2016    if (Utilities.noString(parentType))
2017      t = parent;
2018    else {
2019      t = parent.predicate("fhir:"+parentType+'.'+name);
2020    }
2021    composeBackboneElement(t, "property", name, element, index);
2022    if (element.hasType()) {
2023      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "type", element.getType(), -1);
2024    }
2025    if (element.hasValue()) {
2026      composeType(t, "AdministrableProductDefinitionPropertyComponent", "value", element.getValue(), -1);
2027    }
2028    if (element.hasStatus()) {
2029      composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "status", element.getStatus(), -1);
2030    }
2031  }
2032
2033  protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) {
2034    if (element == null) 
2035      return;
2036    Complex t;
2037    if (Utilities.noString(parentType))
2038      t = parent;
2039    else {
2040      t = parent.predicate("fhir:"+parentType+'.'+name);
2041    }
2042    composeBackboneElement(t, "routeOfAdministration", name, element, index);
2043    if (element.hasCode()) {
2044      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1);
2045    }
2046    if (element.hasFirstDose()) {
2047      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1);
2048    }
2049    if (element.hasMaxSingleDose()) {
2050      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1);
2051    }
2052    if (element.hasMaxDosePerDay()) {
2053      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1);
2054    }
2055    if (element.hasMaxDosePerTreatmentPeriod()) {
2056      composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1);
2057    }
2058    if (element.hasMaxTreatmentPeriod()) {
2059      composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1);
2060    }
2061    for (int i = 0; i < element.getTargetSpecies().size(); i++) {
2062      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i);
2063    }
2064  }
2065
2066  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) {
2067    if (element == null) 
2068      return;
2069    Complex t;
2070    if (Utilities.noString(parentType))
2071      t = parent;
2072    else {
2073      t = parent.predicate("fhir:"+parentType+'.'+name);
2074    }
2075    composeBackboneElement(t, "targetSpecies", name, element, index);
2076    if (element.hasCode()) {
2077      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1);
2078    }
2079    for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) {
2080      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i);
2081    }
2082  }
2083
2084  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) {
2085    if (element == null) 
2086      return;
2087    Complex t;
2088    if (Utilities.noString(parentType))
2089      t = parent;
2090    else {
2091      t = parent.predicate("fhir:"+parentType+'.'+name);
2092    }
2093    composeBackboneElement(t, "withdrawalPeriod", name, element, index);
2094    if (element.hasTissue()) {
2095      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1);
2096    }
2097    if (element.hasValue()) {
2098      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1);
2099    }
2100    if (element.hasSupportingInformationElement()) {
2101      composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1);
2102    }
2103  }
2104
2105  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
2106    if (element == null) 
2107      return;
2108    Complex t;
2109    if (Utilities.noString(parentType))
2110      t = parent;
2111    else {
2112      t = parent.predicate("fhir:"+parentType+'.'+name);
2113    }
2114    composeDomainResource(t, "AdverseEvent", name, element, index);
2115    if (element.hasIdentifier()) {
2116      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1);
2117    }
2118    if (element.hasActualityElement()) {
2119      composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1);
2120    }
2121    for (int i = 0; i < element.getCategory().size(); i++) {
2122      composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i);
2123    }
2124    if (element.hasEvent()) {
2125      composeCodeableConcept(t, "AdverseEvent", "event", element.getEvent(), -1);
2126    }
2127    if (element.hasSubject()) {
2128      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
2129    }
2130    if (element.hasEncounter()) {
2131      composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1);
2132    }
2133    if (element.hasDateElement()) {
2134      composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1);
2135    }
2136    if (element.hasDetectedElement()) {
2137      composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1);
2138    }
2139    if (element.hasRecordedDateElement()) {
2140      composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1);
2141    }
2142    for (int i = 0; i < element.getResultingCondition().size(); i++) {
2143      composeReference(t, "AdverseEvent", "resultingCondition", element.getResultingCondition().get(i), i);
2144    }
2145    if (element.hasLocation()) {
2146      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
2147    }
2148    if (element.hasSeriousness()) {
2149      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
2150    }
2151    if (element.hasSeverity()) {
2152      composeCodeableConcept(t, "AdverseEvent", "severity", element.getSeverity(), -1);
2153    }
2154    if (element.hasOutcome()) {
2155      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1);
2156    }
2157    if (element.hasRecorder()) {
2158      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
2159    }
2160    for (int i = 0; i < element.getContributor().size(); i++) {
2161      composeReference(t, "AdverseEvent", "contributor", element.getContributor().get(i), i);
2162    }
2163    for (int i = 0; i < element.getSuspectEntity().size(); i++) {
2164      composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
2165    }
2166    for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++) {
2167      composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i);
2168    }
2169    for (int i = 0; i < element.getReferenceDocument().size(); i++) {
2170      composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i);
2171    }
2172    for (int i = 0; i < element.getStudy().size(); i++) {
2173      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
2174    }
2175  }
2176
2177  protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) {
2178    if (element == null) 
2179      return;
2180    Complex t;
2181    if (Utilities.noString(parentType))
2182      t = parent;
2183    else {
2184      t = parent.predicate("fhir:"+parentType+'.'+name);
2185    }
2186    composeBackboneElement(t, "suspectEntity", name, element, index);
2187    if (element.hasInstance()) {
2188      composeReference(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1);
2189    }
2190    for (int i = 0; i < element.getCausality().size(); i++) {
2191      composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality().get(i), i);
2192    }
2193  }
2194
2195  protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) {
2196    if (element == null) 
2197      return;
2198    Complex t;
2199    if (Utilities.noString(parentType))
2200      t = parent;
2201    else {
2202      t = parent.predicate("fhir:"+parentType+'.'+name);
2203    }
2204    composeBackboneElement(t, "causality", name, element, index);
2205    if (element.hasAssessment()) {
2206      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessment", element.getAssessment(), -1);
2207    }
2208    if (element.hasProductRelatednessElement()) {
2209      composeString(t, "AdverseEventSuspectEntityCausalityComponent", "productRelatedness", element.getProductRelatednessElement(), -1);
2210    }
2211    if (element.hasAuthor()) {
2212      composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1);
2213    }
2214    if (element.hasMethod()) {
2215      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "method", element.getMethod(), -1);
2216    }
2217  }
2218
2219  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
2220    if (element == null) 
2221      return;
2222    Complex t;
2223    if (Utilities.noString(parentType))
2224      t = parent;
2225    else {
2226      t = parent.predicate("fhir:"+parentType+'.'+name);
2227    }
2228    composeDomainResource(t, "AllergyIntolerance", name, element, index);
2229    for (int i = 0; i < element.getIdentifier().size(); i++) {
2230      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
2231    }
2232    if (element.hasClinicalStatus()) {
2233      composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1);
2234    }
2235    if (element.hasVerificationStatus()) {
2236      composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1);
2237    }
2238    if (element.hasTypeElement()) {
2239      composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1);
2240    }
2241    for (int i = 0; i < element.getCategory().size(); i++) {
2242      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
2243    }
2244    if (element.hasCriticalityElement()) {
2245      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
2246    }
2247    if (element.hasCode()) {
2248      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
2249    }
2250    if (element.hasPatient()) {
2251      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
2252    }
2253    if (element.hasEncounter()) {
2254      composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1);
2255    }
2256    if (element.hasOnset()) {
2257      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
2258    }
2259    if (element.hasRecordedDateElement()) {
2260      composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1);
2261    }
2262    if (element.hasRecorder()) {
2263      composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1);
2264    }
2265    if (element.hasAsserter()) {
2266      composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1);
2267    }
2268    if (element.hasLastOccurrenceElement()) {
2269      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
2270    }
2271    for (int i = 0; i < element.getNote().size(); i++) {
2272      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
2273    }
2274    for (int i = 0; i < element.getReaction().size(); i++) {
2275      composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
2276    }
2277  }
2278
2279  protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
2280    if (element == null) 
2281      return;
2282    Complex t;
2283    if (Utilities.noString(parentType))
2284      t = parent;
2285    else {
2286      t = parent.predicate("fhir:"+parentType+'.'+name);
2287    }
2288    composeBackboneElement(t, "reaction", name, element, index);
2289    if (element.hasSubstance()) {
2290      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1);
2291    }
2292    for (int i = 0; i < element.getManifestation().size(); i++) {
2293      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i);
2294    }
2295    if (element.hasDescriptionElement()) {
2296      composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1);
2297    }
2298    if (element.hasOnsetElement()) {
2299      composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1);
2300    }
2301    if (element.hasSeverityElement()) {
2302      composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1);
2303    }
2304    if (element.hasExposureRoute()) {
2305      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1);
2306    }
2307    for (int i = 0; i < element.getNote().size(); i++) {
2308      composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i);
2309    }
2310  }
2311
2312  protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) {
2313    if (element == null) 
2314      return;
2315    Complex t;
2316    if (Utilities.noString(parentType))
2317      t = parent;
2318    else {
2319      t = parent.predicate("fhir:"+parentType+'.'+name);
2320    }
2321    composeDomainResource(t, "Appointment", name, element, index);
2322    for (int i = 0; i < element.getIdentifier().size(); i++) {
2323      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
2324    }
2325    if (element.hasStatusElement()) {
2326      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
2327    }
2328    if (element.hasCancelationReason()) {
2329      composeCodeableConcept(t, "Appointment", "cancelationReason", element.getCancelationReason(), -1);
2330    }
2331    for (int i = 0; i < element.getServiceCategory().size(); i++) {
2332      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i);
2333    }
2334    for (int i = 0; i < element.getServiceType().size(); i++) {
2335      composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
2336    }
2337    for (int i = 0; i < element.getSpecialty().size(); i++) {
2338      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
2339    }
2340    if (element.hasAppointmentType()) {
2341      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
2342    }
2343    for (int i = 0; i < element.getReasonCode().size(); i++) {
2344      composeCodeableConcept(t, "Appointment", "reasonCode", element.getReasonCode().get(i), i);
2345    }
2346    for (int i = 0; i < element.getReasonReference().size(); i++) {
2347      composeReference(t, "Appointment", "reasonReference", element.getReasonReference().get(i), i);
2348    }
2349    if (element.hasPriorityElement()) {
2350      composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1);
2351    }
2352    if (element.hasDescriptionElement()) {
2353      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
2354    }
2355    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
2356      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
2357    }
2358    if (element.hasStartElement()) {
2359      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
2360    }
2361    if (element.hasEndElement()) {
2362      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
2363    }
2364    if (element.hasMinutesDurationElement()) {
2365      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
2366    }
2367    for (int i = 0; i < element.getSlot().size(); i++) {
2368      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
2369    }
2370    if (element.hasCreatedElement()) {
2371      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
2372    }
2373    if (element.hasCommentElement()) {
2374      composeString(t, "Appointment", "comment", element.getCommentElement(), -1);
2375    }
2376    if (element.hasPatientInstructionElement()) {
2377      composeString(t, "Appointment", "patientInstruction", element.getPatientInstructionElement(), -1);
2378    }
2379    for (int i = 0; i < element.getBasedOn().size(); i++) {
2380      composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i);
2381    }
2382    for (int i = 0; i < element.getParticipant().size(); i++) {
2383      composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
2384    }
2385    for (int i = 0; i < element.getRequestedPeriod().size(); i++) {
2386      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
2387    }
2388  }
2389
2390  protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
2391    if (element == null) 
2392      return;
2393    Complex t;
2394    if (Utilities.noString(parentType))
2395      t = parent;
2396    else {
2397      t = parent.predicate("fhir:"+parentType+'.'+name);
2398    }
2399    composeBackboneElement(t, "participant", name, element, index);
2400    for (int i = 0; i < element.getType().size(); i++) {
2401      composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i);
2402    }
2403    if (element.hasActor()) {
2404      composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1);
2405    }
2406    if (element.hasRequiredElement()) {
2407      composeEnum(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1);
2408    }
2409    if (element.hasStatusElement()) {
2410      composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1);
2411    }
2412    if (element.hasPeriod()) {
2413      composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1);
2414    }
2415  }
2416
2417  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
2418    if (element == null) 
2419      return;
2420    Complex t;
2421    if (Utilities.noString(parentType))
2422      t = parent;
2423    else {
2424      t = parent.predicate("fhir:"+parentType+'.'+name);
2425    }
2426    composeDomainResource(t, "AppointmentResponse", name, element, index);
2427    for (int i = 0; i < element.getIdentifier().size(); i++) {
2428      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
2429    }
2430    if (element.hasAppointment()) {
2431      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
2432    }
2433    if (element.hasStartElement()) {
2434      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
2435    }
2436    if (element.hasEndElement()) {
2437      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
2438    }
2439    for (int i = 0; i < element.getParticipantType().size(); i++) {
2440      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
2441    }
2442    if (element.hasActor()) {
2443      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
2444    }
2445    if (element.hasParticipantStatusElement()) {
2446      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
2447    }
2448    if (element.hasCommentElement()) {
2449      composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
2450    }
2451  }
2452
2453  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) {
2454    if (element == null) 
2455      return;
2456    Complex t;
2457    if (Utilities.noString(parentType))
2458      t = parent;
2459    else {
2460      t = parent.predicate("fhir:"+parentType+'.'+name);
2461    }
2462    composeDomainResource(t, "AuditEvent", name, element, index);
2463    if (element.hasType()) {
2464      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
2465    }
2466    for (int i = 0; i < element.getSubtype().size(); i++) {
2467      composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i);
2468    }
2469    if (element.hasActionElement()) {
2470      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
2471    }
2472    if (element.hasPeriod()) {
2473      composePeriod(t, "AuditEvent", "period", element.getPeriod(), -1);
2474    }
2475    if (element.hasRecordedElement()) {
2476      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
2477    }
2478    if (element.hasOutcomeElement()) {
2479      composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1);
2480    }
2481    if (element.hasOutcomeDescElement()) {
2482      composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1);
2483    }
2484    for (int i = 0; i < element.getPurposeOfEvent().size(); i++) {
2485      composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i);
2486    }
2487    for (int i = 0; i < element.getAgent().size(); i++) {
2488      composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
2489    }
2490    if (element.hasSource()) {
2491      composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
2492    }
2493    for (int i = 0; i < element.getEntity().size(); i++) {
2494      composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
2495    }
2496  }
2497
2498  protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
2499    if (element == null) 
2500      return;
2501    Complex t;
2502    if (Utilities.noString(parentType))
2503      t = parent;
2504    else {
2505      t = parent.predicate("fhir:"+parentType+'.'+name);
2506    }
2507    composeBackboneElement(t, "agent", name, element, index);
2508    if (element.hasType()) {
2509      composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1);
2510    }
2511    for (int i = 0; i < element.getRole().size(); i++) {
2512      composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i);
2513    }
2514    if (element.hasWho()) {
2515      composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1);
2516    }
2517    if (element.hasAltIdElement()) {
2518      composeString(t, "AuditEventAgentComponent", "altId", element.getAltIdElement(), -1);
2519    }
2520    if (element.hasNameElement()) {
2521      composeString(t, "AuditEventAgentComponent", "name", element.getNameElement(), -1);
2522    }
2523    if (element.hasRequestorElement()) {
2524      composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1);
2525    }
2526    if (element.hasLocation()) {
2527      composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1);
2528    }
2529    for (int i = 0; i < element.getPolicy().size(); i++) {
2530      composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i);
2531    }
2532    if (element.hasMedia()) {
2533      composeCoding(t, "AuditEventAgentComponent", "media", element.getMedia(), -1);
2534    }
2535    if (element.hasNetwork()) {
2536      composeAuditEventAgentNetworkComponent(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1);
2537    }
2538    for (int i = 0; i < element.getPurposeOfUse().size(); i++) {
2539      composeCodeableConcept(t, "AuditEventAgentComponent", "purposeOfUse", element.getPurposeOfUse().get(i), i);
2540    }
2541  }
2542
2543  protected void composeAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) {
2544    if (element == null) 
2545      return;
2546    Complex t;
2547    if (Utilities.noString(parentType))
2548      t = parent;
2549    else {
2550      t = parent.predicate("fhir:"+parentType+'.'+name);
2551    }
2552    composeBackboneElement(t, "network", name, element, index);
2553    if (element.hasAddressElement()) {
2554      composeString(t, "AuditEventAgentNetworkComponent", "address", element.getAddressElement(), -1);
2555    }
2556    if (element.hasTypeElement()) {
2557      composeEnum(t, "AuditEventAgentNetworkComponent", "type", element.getTypeElement(), -1);
2558    }
2559  }
2560
2561  protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
2562    if (element == null) 
2563      return;
2564    Complex t;
2565    if (Utilities.noString(parentType))
2566      t = parent;
2567    else {
2568      t = parent.predicate("fhir:"+parentType+'.'+name);
2569    }
2570    composeBackboneElement(t, "source", name, element, index);
2571    if (element.hasSiteElement()) {
2572      composeString(t, "AuditEventSourceComponent", "site", element.getSiteElement(), -1);
2573    }
2574    if (element.hasObserver()) {
2575      composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1);
2576    }
2577    for (int i = 0; i < element.getType().size(); i++) {
2578      composeCoding(t, "AuditEventSourceComponent", "type", element.getType().get(i), i);
2579    }
2580  }
2581
2582  protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
2583    if (element == null) 
2584      return;
2585    Complex t;
2586    if (Utilities.noString(parentType))
2587      t = parent;
2588    else {
2589      t = parent.predicate("fhir:"+parentType+'.'+name);
2590    }
2591    composeBackboneElement(t, "entity", name, element, index);
2592    if (element.hasWhat()) {
2593      composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1);
2594    }
2595    if (element.hasType()) {
2596      composeCoding(t, "AuditEventEntityComponent", "type", element.getType(), -1);
2597    }
2598    if (element.hasRole()) {
2599      composeCoding(t, "AuditEventEntityComponent", "role", element.getRole(), -1);
2600    }
2601    if (element.hasLifecycle()) {
2602      composeCoding(t, "AuditEventEntityComponent", "lifecycle", element.getLifecycle(), -1);
2603    }
2604    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
2605      composeCoding(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i);
2606    }
2607    if (element.hasNameElement()) {
2608      composeString(t, "AuditEventEntityComponent", "name", element.getNameElement(), -1);
2609    }
2610    if (element.hasDescriptionElement()) {
2611      composeString(t, "AuditEventEntityComponent", "description", element.getDescriptionElement(), -1);
2612    }
2613    if (element.hasQueryElement()) {
2614      composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1);
2615    }
2616    for (int i = 0; i < element.getDetail().size(); i++) {
2617      composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i);
2618    }
2619  }
2620
2621  protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
2622    if (element == null) 
2623      return;
2624    Complex t;
2625    if (Utilities.noString(parentType))
2626      t = parent;
2627    else {
2628      t = parent.predicate("fhir:"+parentType+'.'+name);
2629    }
2630    composeBackboneElement(t, "detail", name, element, index);
2631    if (element.hasTypeElement()) {
2632      composeString(t, "AuditEventEntityDetailComponent", "type", element.getTypeElement(), -1);
2633    }
2634    if (element.hasValue()) {
2635      composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1);
2636    }
2637  }
2638
2639  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
2640    if (element == null) 
2641      return;
2642    Complex t;
2643    if (Utilities.noString(parentType))
2644      t = parent;
2645    else {
2646      t = parent.predicate("fhir:"+parentType+'.'+name);
2647    }
2648    composeDomainResource(t, "Basic", name, element, index);
2649    for (int i = 0; i < element.getIdentifier().size(); i++) {
2650      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
2651    }
2652    if (element.hasCode()) {
2653      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
2654    }
2655    if (element.hasSubject()) {
2656      composeReference(t, "Basic", "subject", element.getSubject(), -1);
2657    }
2658    if (element.hasCreatedElement()) {
2659      composeDate(t, "Basic", "created", element.getCreatedElement(), -1);
2660    }
2661    if (element.hasAuthor()) {
2662      composeReference(t, "Basic", "author", element.getAuthor(), -1);
2663    }
2664  }
2665
2666  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
2667    if (element == null) 
2668      return;
2669    Complex t;
2670    if (Utilities.noString(parentType))
2671      t = parent;
2672    else {
2673      t = parent.predicate("fhir:"+parentType+'.'+name);
2674    }
2675    composeResource(t, "Binary", name, element, index);
2676    if (element.hasContentTypeElement()) {
2677      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
2678    }
2679    if (element.hasSecurityContext()) {
2680      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
2681    }
2682    if (element.hasDataElement()) {
2683      composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1);
2684    }
2685  }
2686
2687  protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) {
2688    if (element == null) 
2689      return;
2690    Complex t;
2691    if (Utilities.noString(parentType))
2692      t = parent;
2693    else {
2694      t = parent.predicate("fhir:"+parentType+'.'+name);
2695    }
2696    composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index);
2697    for (int i = 0; i < element.getIdentifier().size(); i++) {
2698      composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i);
2699    }
2700    if (element.hasProductCategoryElement()) {
2701      composeEnum(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategoryElement(), -1);
2702    }
2703    if (element.hasProductCode()) {
2704      composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1);
2705    }
2706    if (element.hasStatusElement()) {
2707      composeEnum(t, "BiologicallyDerivedProduct", "status", element.getStatusElement(), -1);
2708    }
2709    for (int i = 0; i < element.getRequest().size(); i++) {
2710      composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i);
2711    }
2712    if (element.hasQuantityElement()) {
2713      composeInteger(t, "BiologicallyDerivedProduct", "quantity", element.getQuantityElement(), -1);
2714    }
2715    for (int i = 0; i < element.getParent().size(); i++) {
2716      composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i);
2717    }
2718    if (element.hasCollection()) {
2719      composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1);
2720    }
2721    for (int i = 0; i < element.getProcessing().size(); i++) {
2722      composeBiologicallyDerivedProductProcessingComponent(t, "BiologicallyDerivedProduct", "processing", element.getProcessing().get(i), i);
2723    }
2724    if (element.hasManipulation()) {
2725      composeBiologicallyDerivedProductManipulationComponent(t, "BiologicallyDerivedProduct", "manipulation", element.getManipulation(), -1);
2726    }
2727    for (int i = 0; i < element.getStorage().size(); i++) {
2728      composeBiologicallyDerivedProductStorageComponent(t, "BiologicallyDerivedProduct", "storage", element.getStorage().get(i), i);
2729    }
2730  }
2731
2732  protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) {
2733    if (element == null) 
2734      return;
2735    Complex t;
2736    if (Utilities.noString(parentType))
2737      t = parent;
2738    else {
2739      t = parent.predicate("fhir:"+parentType+'.'+name);
2740    }
2741    composeBackboneElement(t, "collection", name, element, index);
2742    if (element.hasCollector()) {
2743      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1);
2744    }
2745    if (element.hasSource()) {
2746      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1);
2747    }
2748    if (element.hasCollected()) {
2749      composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1);
2750    }
2751  }
2752
2753  protected void composeBiologicallyDerivedProductProcessingComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductProcessingComponent element, int index) {
2754    if (element == null) 
2755      return;
2756    Complex t;
2757    if (Utilities.noString(parentType))
2758      t = parent;
2759    else {
2760      t = parent.predicate("fhir:"+parentType+'.'+name);
2761    }
2762    composeBackboneElement(t, "processing", name, element, index);
2763    if (element.hasDescriptionElement()) {
2764      composeString(t, "BiologicallyDerivedProductProcessingComponent", "description", element.getDescriptionElement(), -1);
2765    }
2766    if (element.hasProcedure()) {
2767      composeCodeableConcept(t, "BiologicallyDerivedProductProcessingComponent", "procedure", element.getProcedure(), -1);
2768    }
2769    if (element.hasAdditive()) {
2770      composeReference(t, "BiologicallyDerivedProductProcessingComponent", "additive", element.getAdditive(), -1);
2771    }
2772    if (element.hasTime()) {
2773      composeType(t, "BiologicallyDerivedProductProcessingComponent", "time", element.getTime(), -1);
2774    }
2775  }
2776
2777  protected void composeBiologicallyDerivedProductManipulationComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductManipulationComponent element, int index) {
2778    if (element == null) 
2779      return;
2780    Complex t;
2781    if (Utilities.noString(parentType))
2782      t = parent;
2783    else {
2784      t = parent.predicate("fhir:"+parentType+'.'+name);
2785    }
2786    composeBackboneElement(t, "manipulation", name, element, index);
2787    if (element.hasDescriptionElement()) {
2788      composeString(t, "BiologicallyDerivedProductManipulationComponent", "description", element.getDescriptionElement(), -1);
2789    }
2790    if (element.hasTime()) {
2791      composeType(t, "BiologicallyDerivedProductManipulationComponent", "time", element.getTime(), -1);
2792    }
2793  }
2794
2795  protected void composeBiologicallyDerivedProductStorageComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductStorageComponent element, int index) {
2796    if (element == null) 
2797      return;
2798    Complex t;
2799    if (Utilities.noString(parentType))
2800      t = parent;
2801    else {
2802      t = parent.predicate("fhir:"+parentType+'.'+name);
2803    }
2804    composeBackboneElement(t, "storage", name, element, index);
2805    if (element.hasDescriptionElement()) {
2806      composeString(t, "BiologicallyDerivedProductStorageComponent", "description", element.getDescriptionElement(), -1);
2807    }
2808    if (element.hasTemperatureElement()) {
2809      composeDecimal(t, "BiologicallyDerivedProductStorageComponent", "temperature", element.getTemperatureElement(), -1);
2810    }
2811    if (element.hasScaleElement()) {
2812      composeEnum(t, "BiologicallyDerivedProductStorageComponent", "scale", element.getScaleElement(), -1);
2813    }
2814    if (element.hasDuration()) {
2815      composePeriod(t, "BiologicallyDerivedProductStorageComponent", "duration", element.getDuration(), -1);
2816    }
2817  }
2818
2819  protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) {
2820    if (element == null) 
2821      return;
2822    Complex t;
2823    if (Utilities.noString(parentType))
2824      t = parent;
2825    else {
2826      t = parent.predicate("fhir:"+parentType+'.'+name);
2827    }
2828    composeDomainResource(t, "BodyStructure", name, element, index);
2829    for (int i = 0; i < element.getIdentifier().size(); i++) {
2830      composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i);
2831    }
2832    if (element.hasActiveElement()) {
2833      composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1);
2834    }
2835    if (element.hasMorphology()) {
2836      composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1);
2837    }
2838    if (element.hasLocation()) {
2839      composeCodeableConcept(t, "BodyStructure", "location", element.getLocation(), -1);
2840    }
2841    for (int i = 0; i < element.getLocationQualifier().size(); i++) {
2842      composeCodeableConcept(t, "BodyStructure", "locationQualifier", element.getLocationQualifier().get(i), i);
2843    }
2844    if (element.hasDescriptionElement()) {
2845      composeString(t, "BodyStructure", "description", element.getDescriptionElement(), -1);
2846    }
2847    for (int i = 0; i < element.getImage().size(); i++) {
2848      composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i);
2849    }
2850    if (element.hasPatient()) {
2851      composeReference(t, "BodyStructure", "patient", element.getPatient(), -1);
2852    }
2853  }
2854
2855  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
2856    if (element == null) 
2857      return;
2858    Complex t;
2859    if (Utilities.noString(parentType))
2860      t = parent;
2861    else {
2862      t = parent.predicate("fhir:"+parentType+'.'+name);
2863    }
2864    composeResource(t, "Bundle", name, element, index);
2865    if (element.hasIdentifier()) {
2866      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
2867    }
2868    if (element.hasTypeElement()) {
2869      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
2870    }
2871    if (element.hasTimestampElement()) {
2872      composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1);
2873    }
2874    if (element.hasTotalElement()) {
2875      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
2876    }
2877    for (int i = 0; i < element.getLink().size(); i++) {
2878      composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
2879    }
2880    for (int i = 0; i < element.getEntry().size(); i++) {
2881      composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
2882    }
2883    if (element.hasSignature()) {
2884      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
2885    }
2886  }
2887
2888  protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) {
2889    if (element == null) 
2890      return;
2891    Complex t;
2892    if (Utilities.noString(parentType))
2893      t = parent;
2894    else {
2895      t = parent.predicate("fhir:"+parentType+'.'+name);
2896    }
2897    composeBackboneElement(t, "link", name, element, index);
2898    if (element.hasRelationElement()) {
2899      composeString(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1);
2900    }
2901    if (element.hasUrlElement()) {
2902      composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1);
2903    }
2904  }
2905
2906  protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) {
2907    if (element == null) 
2908      return;
2909    Complex t;
2910    if (Utilities.noString(parentType))
2911      t = parent;
2912    else {
2913      t = parent.predicate("fhir:"+parentType+'.'+name);
2914    }
2915    composeBackboneElement(t, "entry", name, element, index);
2916    for (int i = 0; i < element.getLink().size(); i++) {
2917      composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i);
2918    }
2919    if (element.hasFullUrlElement()) {
2920      composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1);
2921    }
2922    if (element.hasResource()) {
2923      composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1);
2924    }
2925    if (element.hasSearch()) {
2926      composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1);
2927    }
2928    if (element.hasRequest()) {
2929      composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1);
2930    }
2931    if (element.hasResponse()) {
2932      composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1);
2933    }
2934  }
2935
2936  protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
2937    if (element == null) 
2938      return;
2939    Complex t;
2940    if (Utilities.noString(parentType))
2941      t = parent;
2942    else {
2943      t = parent.predicate("fhir:"+parentType+'.'+name);
2944    }
2945    composeBackboneElement(t, "search", name, element, index);
2946    if (element.hasModeElement()) {
2947      composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1);
2948    }
2949    if (element.hasScoreElement()) {
2950      composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1);
2951    }
2952  }
2953
2954  protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
2955    if (element == null) 
2956      return;
2957    Complex t;
2958    if (Utilities.noString(parentType))
2959      t = parent;
2960    else {
2961      t = parent.predicate("fhir:"+parentType+'.'+name);
2962    }
2963    composeBackboneElement(t, "request", name, element, index);
2964    if (element.hasMethodElement()) {
2965      composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1);
2966    }
2967    if (element.hasUrlElement()) {
2968      composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1);
2969    }
2970    if (element.hasIfNoneMatchElement()) {
2971      composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
2972    }
2973    if (element.hasIfModifiedSinceElement()) {
2974      composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
2975    }
2976    if (element.hasIfMatchElement()) {
2977      composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1);
2978    }
2979    if (element.hasIfNoneExistElement()) {
2980      composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1);
2981    }
2982  }
2983
2984  protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
2985    if (element == null) 
2986      return;
2987    Complex t;
2988    if (Utilities.noString(parentType))
2989      t = parent;
2990    else {
2991      t = parent.predicate("fhir:"+parentType+'.'+name);
2992    }
2993    composeBackboneElement(t, "response", name, element, index);
2994    if (element.hasStatusElement()) {
2995      composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1);
2996    }
2997    if (element.hasLocationElement()) {
2998      composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1);
2999    }
3000    if (element.hasEtagElement()) {
3001      composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1);
3002    }
3003    if (element.hasLastModifiedElement()) {
3004      composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1);
3005    }
3006    if (element.hasOutcome()) {
3007      composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1);
3008    }
3009  }
3010
3011  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) {
3012    if (element == null) 
3013      return;
3014    Complex t;
3015    if (Utilities.noString(parentType))
3016      t = parent;
3017    else {
3018      t = parent.predicate("fhir:"+parentType+'.'+name);
3019    }
3020    composeDomainResource(t, "CapabilityStatement", name, element, index);
3021    if (element.hasUrlElement()) {
3022      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
3023    }
3024    if (element.hasVersionElement()) {
3025      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
3026    }
3027    if (element.hasNameElement()) {
3028      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
3029    }
3030    if (element.hasTitleElement()) {
3031      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
3032    }
3033    if (element.hasStatusElement()) {
3034      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
3035    }
3036    if (element.hasExperimentalElement()) {
3037      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
3038    }
3039    if (element.hasDateElement()) {
3040      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
3041    }
3042    if (element.hasPublisherElement()) {
3043      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
3044    }
3045    for (int i = 0; i < element.getContact().size(); i++) {
3046      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
3047    }
3048    if (element.hasDescriptionElement()) {
3049      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
3050    }
3051    for (int i = 0; i < element.getUseContext().size(); i++) {
3052      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
3053    }
3054    for (int i = 0; i < element.getJurisdiction().size(); i++) {
3055      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
3056    }
3057    if (element.hasPurposeElement()) {
3058      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
3059    }
3060    if (element.hasCopyrightElement()) {
3061      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
3062    }
3063    if (element.hasKindElement()) {
3064      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
3065    }
3066    for (int i = 0; i < element.getInstantiates().size(); i++) {
3067      composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
3068    }
3069    for (int i = 0; i < element.getImports().size(); i++) {
3070      composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i);
3071    }
3072    if (element.hasSoftware()) {
3073      composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
3074    }
3075    if (element.hasImplementation()) {
3076      composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
3077    }
3078    if (element.hasFhirVersionElement()) {
3079      composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
3080    }
3081    for (int i = 0; i < element.getFormat().size(); i++) {
3082      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
3083    }
3084    for (int i = 0; i < element.getPatchFormat().size(); i++) {
3085      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
3086    }
3087    for (int i = 0; i < element.getImplementationGuide().size(); i++) {
3088      composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
3089    }
3090    for (int i = 0; i < element.getRest().size(); i++) {
3091      composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
3092    }
3093    for (int i = 0; i < element.getMessaging().size(); i++) {
3094      composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
3095    }
3096    for (int i = 0; i < element.getDocument().size(); i++) {
3097      composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
3098    }
3099  }
3100
3101  protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
3102    if (element == null) 
3103      return;
3104    Complex t;
3105    if (Utilities.noString(parentType))
3106      t = parent;
3107    else {
3108      t = parent.predicate("fhir:"+parentType+'.'+name);
3109    }
3110    composeBackboneElement(t, "software", name, element, index);
3111    if (element.hasNameElement()) {
3112      composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1);
3113    }
3114    if (element.hasVersionElement()) {
3115      composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1);
3116    }
3117    if (element.hasReleaseDateElement()) {
3118      composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1);
3119    }
3120  }
3121
3122  protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
3123    if (element == null) 
3124      return;
3125    Complex t;
3126    if (Utilities.noString(parentType))
3127      t = parent;
3128    else {
3129      t = parent.predicate("fhir:"+parentType+'.'+name);
3130    }
3131    composeBackboneElement(t, "implementation", name, element, index);
3132    if (element.hasDescriptionElement()) {
3133      composeString(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1);
3134    }
3135    if (element.hasUrlElement()) {
3136      composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1);
3137    }
3138    if (element.hasCustodian()) {
3139      composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1);
3140    }
3141  }
3142
3143  protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
3144    if (element == null) 
3145      return;
3146    Complex t;
3147    if (Utilities.noString(parentType))
3148      t = parent;
3149    else {
3150      t = parent.predicate("fhir:"+parentType+'.'+name);
3151    }
3152    composeBackboneElement(t, "rest", name, element, index);
3153    if (element.hasModeElement()) {
3154      composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1);
3155    }
3156    if (element.hasDocumentationElement()) {
3157      composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1);
3158    }
3159    if (element.hasSecurity()) {
3160      composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1);
3161    }
3162    for (int i = 0; i < element.getResource().size(); i++) {
3163      composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i);
3164    }
3165    for (int i = 0; i < element.getInteraction().size(); i++) {
3166      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i);
3167    }
3168    for (int i = 0; i < element.getSearchParam().size(); i++) {
3169      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i);
3170    }
3171    for (int i = 0; i < element.getOperation().size(); i++) {
3172      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i);
3173    }
3174    for (int i = 0; i < element.getCompartment().size(); i++) {
3175      composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i);
3176    }
3177  }
3178
3179  protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
3180    if (element == null) 
3181      return;
3182    Complex t;
3183    if (Utilities.noString(parentType))
3184      t = parent;
3185    else {
3186      t = parent.predicate("fhir:"+parentType+'.'+name);
3187    }
3188    composeBackboneElement(t, "security", name, element, index);
3189    if (element.hasCorsElement()) {
3190      composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1);
3191    }
3192    for (int i = 0; i < element.getService().size(); i++) {
3193      composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i);
3194    }
3195    if (element.hasDescriptionElement()) {
3196      composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1);
3197    }
3198  }
3199
3200  protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
3201    if (element == null) 
3202      return;
3203    Complex t;
3204    if (Utilities.noString(parentType))
3205      t = parent;
3206    else {
3207      t = parent.predicate("fhir:"+parentType+'.'+name);
3208    }
3209    composeBackboneElement(t, "resource", name, element, index);
3210    if (element.hasTypeElement()) {
3211      composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1);
3212    }
3213    if (element.hasProfileElement()) {
3214      composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1);
3215    }
3216    for (int i = 0; i < element.getSupportedProfile().size(); i++) {
3217      composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i);
3218    }
3219    if (element.hasDocumentationElement()) {
3220      composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1);
3221    }
3222    for (int i = 0; i < element.getInteraction().size(); i++) {
3223      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i);
3224    }
3225    if (element.hasVersioningElement()) {
3226      composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1);
3227    }
3228    if (element.hasReadHistoryElement()) {
3229      composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1);
3230    }
3231    if (element.hasUpdateCreateElement()) {
3232      composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1);
3233    }
3234    if (element.hasConditionalCreateElement()) {
3235      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1);
3236    }
3237    if (element.hasConditionalReadElement()) {
3238      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1);
3239    }
3240    if (element.hasConditionalUpdateElement()) {
3241      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
3242    }
3243    if (element.hasConditionalDeleteElement()) {
3244      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1);
3245    }
3246    for (int i = 0; i < element.getReferencePolicy().size(); i++) {
3247      composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i);
3248    }
3249    for (int i = 0; i < element.getSearchInclude().size(); i++) {
3250      composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i);
3251    }
3252    for (int i = 0; i < element.getSearchRevInclude().size(); i++) {
3253      composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i);
3254    }
3255    for (int i = 0; i < element.getSearchParam().size(); i++) {
3256      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i);
3257    }
3258    for (int i = 0; i < element.getOperation().size(); i++) {
3259      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i);
3260    }
3261  }
3262
3263  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
3264    if (element == null) 
3265      return;
3266    Complex t;
3267    if (Utilities.noString(parentType))
3268      t = parent;
3269    else {
3270      t = parent.predicate("fhir:"+parentType+'.'+name);
3271    }
3272    composeBackboneElement(t, "interaction", name, element, index);
3273    if (element.hasCodeElement()) {
3274      composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1);
3275    }
3276    if (element.hasDocumentationElement()) {
3277      composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1);
3278    }
3279  }
3280
3281  protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
3282    if (element == null) 
3283      return;
3284    Complex t;
3285    if (Utilities.noString(parentType))
3286      t = parent;
3287    else {
3288      t = parent.predicate("fhir:"+parentType+'.'+name);
3289    }
3290    composeBackboneElement(t, "searchParam", name, element, index);
3291    if (element.hasNameElement()) {
3292      composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1);
3293    }
3294    if (element.hasDefinitionElement()) {
3295      composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1);
3296    }
3297    if (element.hasTypeElement()) {
3298      composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1);
3299    }
3300    if (element.hasDocumentationElement()) {
3301      composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1);
3302    }
3303  }
3304
3305  protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) {
3306    if (element == null) 
3307      return;
3308    Complex t;
3309    if (Utilities.noString(parentType))
3310      t = parent;
3311    else {
3312      t = parent.predicate("fhir:"+parentType+'.'+name);
3313    }
3314    composeBackboneElement(t, "operation", name, element, index);
3315    if (element.hasNameElement()) {
3316      composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1);
3317    }
3318    if (element.hasDefinitionElement()) {
3319      composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1);
3320    }
3321    if (element.hasDocumentationElement()) {
3322      composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1);
3323    }
3324  }
3325
3326  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
3327    if (element == null) 
3328      return;
3329    Complex t;
3330    if (Utilities.noString(parentType))
3331      t = parent;
3332    else {
3333      t = parent.predicate("fhir:"+parentType+'.'+name);
3334    }
3335    composeBackboneElement(t, "interaction", name, element, index);
3336    if (element.hasCodeElement()) {
3337      composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1);
3338    }
3339    if (element.hasDocumentationElement()) {
3340      composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1);
3341    }
3342  }
3343
3344  protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
3345    if (element == null) 
3346      return;
3347    Complex t;
3348    if (Utilities.noString(parentType))
3349      t = parent;
3350    else {
3351      t = parent.predicate("fhir:"+parentType+'.'+name);
3352    }
3353    composeBackboneElement(t, "messaging", name, element, index);
3354    for (int i = 0; i < element.getEndpoint().size(); i++) {
3355      composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i);
3356    }
3357    if (element.hasReliableCacheElement()) {
3358      composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1);
3359    }
3360    if (element.hasDocumentationElement()) {
3361      composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1);
3362    }
3363    for (int i = 0; i < element.getSupportedMessage().size(); i++) {
3364      composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i);
3365    }
3366  }
3367
3368  protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
3369    if (element == null) 
3370      return;
3371    Complex t;
3372    if (Utilities.noString(parentType))
3373      t = parent;
3374    else {
3375      t = parent.predicate("fhir:"+parentType+'.'+name);
3376    }
3377    composeBackboneElement(t, "endpoint", name, element, index);
3378    if (element.hasProtocol()) {
3379      composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1);
3380    }
3381    if (element.hasAddressElement()) {
3382      composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1);
3383    }
3384  }
3385
3386  protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
3387    if (element == null) 
3388      return;
3389    Complex t;
3390    if (Utilities.noString(parentType))
3391      t = parent;
3392    else {
3393      t = parent.predicate("fhir:"+parentType+'.'+name);
3394    }
3395    composeBackboneElement(t, "supportedMessage", name, element, index);
3396    if (element.hasModeElement()) {
3397      composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1);
3398    }
3399    if (element.hasDefinitionElement()) {
3400      composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1);
3401    }
3402  }
3403
3404  protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
3405    if (element == null) 
3406      return;
3407    Complex t;
3408    if (Utilities.noString(parentType))
3409      t = parent;
3410    else {
3411      t = parent.predicate("fhir:"+parentType+'.'+name);
3412    }
3413    composeBackboneElement(t, "document", name, element, index);
3414    if (element.hasModeElement()) {
3415      composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1);
3416    }
3417    if (element.hasDocumentationElement()) {
3418      composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1);
3419    }
3420    if (element.hasProfileElement()) {
3421      composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1);
3422    }
3423  }
3424
3425  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
3426    if (element == null) 
3427      return;
3428    Complex t;
3429    if (Utilities.noString(parentType))
3430      t = parent;
3431    else {
3432      t = parent.predicate("fhir:"+parentType+'.'+name);
3433    }
3434    composeDomainResource(t, "CarePlan", name, element, index);
3435    for (int i = 0; i < element.getIdentifier().size(); i++) {
3436      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
3437    }
3438    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
3439      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
3440    }
3441    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
3442      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
3443    }
3444    for (int i = 0; i < element.getBasedOn().size(); i++) {
3445      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
3446    }
3447    for (int i = 0; i < element.getReplaces().size(); i++) {
3448      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
3449    }
3450    for (int i = 0; i < element.getPartOf().size(); i++) {
3451      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
3452    }
3453    if (element.hasStatusElement()) {
3454      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
3455    }
3456    if (element.hasIntentElement()) {
3457      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
3458    }
3459    for (int i = 0; i < element.getCategory().size(); i++) {
3460      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
3461    }
3462    if (element.hasTitleElement()) {
3463      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
3464    }
3465    if (element.hasDescriptionElement()) {
3466      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
3467    }
3468    if (element.hasSubject()) {
3469      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
3470    }
3471    if (element.hasEncounter()) {
3472      composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1);
3473    }
3474    if (element.hasPeriod()) {
3475      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
3476    }
3477    if (element.hasCreatedElement()) {
3478      composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1);
3479    }
3480    if (element.hasAuthor()) {
3481      composeReference(t, "CarePlan", "author", element.getAuthor(), -1);
3482    }
3483    for (int i = 0; i < element.getContributor().size(); i++) {
3484      composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i);
3485    }
3486    for (int i = 0; i < element.getCareTeam().size(); i++) {
3487      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
3488    }
3489    for (int i = 0; i < element.getAddresses().size(); i++) {
3490      composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
3491    }
3492    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
3493      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
3494    }
3495    for (int i = 0; i < element.getGoal().size(); i++) {
3496      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
3497    }
3498    for (int i = 0; i < element.getActivity().size(); i++) {
3499      composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
3500    }
3501    for (int i = 0; i < element.getNote().size(); i++) {
3502      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
3503    }
3504  }
3505
3506  protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
3507    if (element == null) 
3508      return;
3509    Complex t;
3510    if (Utilities.noString(parentType))
3511      t = parent;
3512    else {
3513      t = parent.predicate("fhir:"+parentType+'.'+name);
3514    }
3515    composeBackboneElement(t, "activity", name, element, index);
3516    for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++) {
3517      composeCodeableConcept(t, "CarePlanActivityComponent", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i);
3518    }
3519    for (int i = 0; i < element.getOutcomeReference().size(); i++) {
3520      composeReference(t, "CarePlanActivityComponent", "outcomeReference", element.getOutcomeReference().get(i), i);
3521    }
3522    for (int i = 0; i < element.getProgress().size(); i++) {
3523      composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i);
3524    }
3525    if (element.hasReference()) {
3526      composeReference(t, "CarePlanActivityComponent", "reference", element.getReference(), -1);
3527    }
3528    if (element.hasDetail()) {
3529      composeCarePlanActivityDetailComponent(t, "CarePlanActivityComponent", "detail", element.getDetail(), -1);
3530    }
3531  }
3532
3533  protected void composeCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) {
3534    if (element == null) 
3535      return;
3536    Complex t;
3537    if (Utilities.noString(parentType))
3538      t = parent;
3539    else {
3540      t = parent.predicate("fhir:"+parentType+'.'+name);
3541    }
3542    composeBackboneElement(t, "detail", name, element, index);
3543    if (element.hasKindElement()) {
3544      composeEnum(t, "CarePlanActivityDetailComponent", "kind", element.getKindElement(), -1);
3545    }
3546    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
3547      composeCanonical(t, "CarePlanActivityDetailComponent", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
3548    }
3549    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
3550      composeUri(t, "CarePlanActivityDetailComponent", "instantiatesUri", element.getInstantiatesUri().get(i), i);
3551    }
3552    if (element.hasCode()) {
3553      composeCodeableConcept(t, "CarePlanActivityDetailComponent", "code", element.getCode(), -1);
3554    }
3555    for (int i = 0; i < element.getReasonCode().size(); i++) {
3556      composeCodeableConcept(t, "CarePlanActivityDetailComponent", "reasonCode", element.getReasonCode().get(i), i);
3557    }
3558    for (int i = 0; i < element.getReasonReference().size(); i++) {
3559      composeReference(t, "CarePlanActivityDetailComponent", "reasonReference", element.getReasonReference().get(i), i);
3560    }
3561    for (int i = 0; i < element.getGoal().size(); i++) {
3562      composeReference(t, "CarePlanActivityDetailComponent", "goal", element.getGoal().get(i), i);
3563    }
3564    if (element.hasStatusElement()) {
3565      composeEnum(t, "CarePlanActivityDetailComponent", "status", element.getStatusElement(), -1);
3566    }
3567    if (element.hasStatusReason()) {
3568      composeCodeableConcept(t, "CarePlanActivityDetailComponent", "statusReason", element.getStatusReason(), -1);
3569    }
3570    if (element.hasDoNotPerformElement()) {
3571      composeBoolean(t, "CarePlanActivityDetailComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
3572    }
3573    if (element.hasScheduled()) {
3574      composeType(t, "CarePlanActivityDetailComponent", "scheduled", element.getScheduled(), -1);
3575    }
3576    if (element.hasLocation()) {
3577      composeReference(t, "CarePlanActivityDetailComponent", "location", element.getLocation(), -1);
3578    }
3579    for (int i = 0; i < element.getPerformer().size(); i++) {
3580      composeReference(t, "CarePlanActivityDetailComponent", "performer", element.getPerformer().get(i), i);
3581    }
3582    if (element.hasProduct()) {
3583      composeType(t, "CarePlanActivityDetailComponent", "product", element.getProduct(), -1);
3584    }
3585    if (element.hasDailyAmount()) {
3586      composeQuantity(t, "CarePlanActivityDetailComponent", "dailyAmount", element.getDailyAmount(), -1);
3587    }
3588    if (element.hasQuantity()) {
3589      composeQuantity(t, "CarePlanActivityDetailComponent", "quantity", element.getQuantity(), -1);
3590    }
3591    if (element.hasDescriptionElement()) {
3592      composeString(t, "CarePlanActivityDetailComponent", "description", element.getDescriptionElement(), -1);
3593    }
3594  }
3595
3596  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
3597    if (element == null) 
3598      return;
3599    Complex t;
3600    if (Utilities.noString(parentType))
3601      t = parent;
3602    else {
3603      t = parent.predicate("fhir:"+parentType+'.'+name);
3604    }
3605    composeDomainResource(t, "CareTeam", name, element, index);
3606    for (int i = 0; i < element.getIdentifier().size(); i++) {
3607      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
3608    }
3609    if (element.hasStatusElement()) {
3610      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
3611    }
3612    for (int i = 0; i < element.getCategory().size(); i++) {
3613      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
3614    }
3615    if (element.hasNameElement()) {
3616      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
3617    }
3618    if (element.hasSubject()) {
3619      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
3620    }
3621    if (element.hasEncounter()) {
3622      composeReference(t, "CareTeam", "encounter", element.getEncounter(), -1);
3623    }
3624    if (element.hasPeriod()) {
3625      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
3626    }
3627    for (int i = 0; i < element.getParticipant().size(); i++) {
3628      composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
3629    }
3630    for (int i = 0; i < element.getReasonCode().size(); i++) {
3631      composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i);
3632    }
3633    for (int i = 0; i < element.getReasonReference().size(); i++) {
3634      composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i);
3635    }
3636    for (int i = 0; i < element.getManagingOrganization().size(); i++) {
3637      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
3638    }
3639    for (int i = 0; i < element.getTelecom().size(); i++) {
3640      composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i);
3641    }
3642    for (int i = 0; i < element.getNote().size(); i++) {
3643      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
3644    }
3645  }
3646
3647  protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
3648    if (element == null) 
3649      return;
3650    Complex t;
3651    if (Utilities.noString(parentType))
3652      t = parent;
3653    else {
3654      t = parent.predicate("fhir:"+parentType+'.'+name);
3655    }
3656    composeBackboneElement(t, "participant", name, element, index);
3657    for (int i = 0; i < element.getRole().size(); i++) {
3658      composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole().get(i), i);
3659    }
3660    if (element.hasMember()) {
3661      composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1);
3662    }
3663    if (element.hasOnBehalfOf()) {
3664      composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
3665    }
3666    if (element.hasPeriod()) {
3667      composePeriod(t, "CareTeamParticipantComponent", "period", element.getPeriod(), -1);
3668    }
3669  }
3670
3671  protected void composeCatalogEntry(Complex parent, String parentType, String name, CatalogEntry element, int index) {
3672    if (element == null) 
3673      return;
3674    Complex t;
3675    if (Utilities.noString(parentType))
3676      t = parent;
3677    else {
3678      t = parent.predicate("fhir:"+parentType+'.'+name);
3679    }
3680    composeDomainResource(t, "CatalogEntry", name, element, index);
3681    for (int i = 0; i < element.getIdentifier().size(); i++) {
3682      composeIdentifier(t, "CatalogEntry", "identifier", element.getIdentifier().get(i), i);
3683    }
3684    if (element.hasType()) {
3685      composeCodeableConcept(t, "CatalogEntry", "type", element.getType(), -1);
3686    }
3687    if (element.hasOrderableElement()) {
3688      composeBoolean(t, "CatalogEntry", "orderable", element.getOrderableElement(), -1);
3689    }
3690    if (element.hasReferencedItem()) {
3691      composeReference(t, "CatalogEntry", "referencedItem", element.getReferencedItem(), -1);
3692    }
3693    for (int i = 0; i < element.getAdditionalIdentifier().size(); i++) {
3694      composeIdentifier(t, "CatalogEntry", "additionalIdentifier", element.getAdditionalIdentifier().get(i), i);
3695    }
3696    for (int i = 0; i < element.getClassification().size(); i++) {
3697      composeCodeableConcept(t, "CatalogEntry", "classification", element.getClassification().get(i), i);
3698    }
3699    if (element.hasStatusElement()) {
3700      composeEnum(t, "CatalogEntry", "status", element.getStatusElement(), -1);
3701    }
3702    if (element.hasValidityPeriod()) {
3703      composePeriod(t, "CatalogEntry", "validityPeriod", element.getValidityPeriod(), -1);
3704    }
3705    if (element.hasValidToElement()) {
3706      composeDateTime(t, "CatalogEntry", "validTo", element.getValidToElement(), -1);
3707    }
3708    if (element.hasLastUpdatedElement()) {
3709      composeDateTime(t, "CatalogEntry", "lastUpdated", element.getLastUpdatedElement(), -1);
3710    }
3711    for (int i = 0; i < element.getAdditionalCharacteristic().size(); i++) {
3712      composeCodeableConcept(t, "CatalogEntry", "additionalCharacteristic", element.getAdditionalCharacteristic().get(i), i);
3713    }
3714    for (int i = 0; i < element.getAdditionalClassification().size(); i++) {
3715      composeCodeableConcept(t, "CatalogEntry", "additionalClassification", element.getAdditionalClassification().get(i), i);
3716    }
3717    for (int i = 0; i < element.getRelatedEntry().size(); i++) {
3718      composeCatalogEntryRelatedEntryComponent(t, "CatalogEntry", "relatedEntry", element.getRelatedEntry().get(i), i);
3719    }
3720  }
3721
3722  protected void composeCatalogEntryRelatedEntryComponent(Complex parent, String parentType, String name, CatalogEntry.CatalogEntryRelatedEntryComponent element, int index) {
3723    if (element == null) 
3724      return;
3725    Complex t;
3726    if (Utilities.noString(parentType))
3727      t = parent;
3728    else {
3729      t = parent.predicate("fhir:"+parentType+'.'+name);
3730    }
3731    composeBackboneElement(t, "relatedEntry", name, element, index);
3732    if (element.hasRelationtypeElement()) {
3733      composeEnum(t, "CatalogEntryRelatedEntryComponent", "relationtype", element.getRelationtypeElement(), -1);
3734    }
3735    if (element.hasItem()) {
3736      composeReference(t, "CatalogEntryRelatedEntryComponent", "item", element.getItem(), -1);
3737    }
3738  }
3739
3740  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
3741    if (element == null) 
3742      return;
3743    Complex t;
3744    if (Utilities.noString(parentType))
3745      t = parent;
3746    else {
3747      t = parent.predicate("fhir:"+parentType+'.'+name);
3748    }
3749    composeDomainResource(t, "ChargeItem", name, element, index);
3750    for (int i = 0; i < element.getIdentifier().size(); i++) {
3751      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i);
3752    }
3753    for (int i = 0; i < element.getDefinitionUri().size(); i++) {
3754      composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i);
3755    }
3756    for (int i = 0; i < element.getDefinitionCanonical().size(); i++) {
3757      composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i);
3758    }
3759    if (element.hasStatusElement()) {
3760      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
3761    }
3762    for (int i = 0; i < element.getPartOf().size(); i++) {
3763      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
3764    }
3765    if (element.hasCode()) {
3766      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
3767    }
3768    if (element.hasSubject()) {
3769      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
3770    }
3771    if (element.hasContext()) {
3772      composeReference(t, "ChargeItem", "context", element.getContext(), -1);
3773    }
3774    if (element.hasOccurrence()) {
3775      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
3776    }
3777    for (int i = 0; i < element.getPerformer().size(); i++) {
3778      composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i);
3779    }
3780    if (element.hasPerformingOrganization()) {
3781      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
3782    }
3783    if (element.hasRequestingOrganization()) {
3784      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
3785    }
3786    if (element.hasCostCenter()) {
3787      composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1);
3788    }
3789    if (element.hasQuantity()) {
3790      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
3791    }
3792    for (int i = 0; i < element.getBodysite().size(); i++) {
3793      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
3794    }
3795    if (element.hasFactorOverrideElement()) {
3796      composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1);
3797    }
3798    if (element.hasPriceOverride()) {
3799      composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1);
3800    }
3801    if (element.hasOverrideReasonElement()) {
3802      composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1);
3803    }
3804    if (element.hasEnterer()) {
3805      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
3806    }
3807    if (element.hasEnteredDateElement()) {
3808      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
3809    }
3810    for (int i = 0; i < element.getReason().size(); i++) {
3811      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
3812    }
3813    for (int i = 0; i < element.getService().size(); i++) {
3814      composeReference(t, "ChargeItem", "service", element.getService().get(i), i);
3815    }
3816    if (element.hasProduct()) {
3817      composeType(t, "ChargeItem", "product", element.getProduct(), -1);
3818    }
3819    for (int i = 0; i < element.getAccount().size(); i++) {
3820      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
3821    }
3822    for (int i = 0; i < element.getNote().size(); i++) {
3823      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
3824    }
3825    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
3826      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
3827    }
3828  }
3829
3830  protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) {
3831    if (element == null) 
3832      return;
3833    Complex t;
3834    if (Utilities.noString(parentType))
3835      t = parent;
3836    else {
3837      t = parent.predicate("fhir:"+parentType+'.'+name);
3838    }
3839    composeBackboneElement(t, "performer", name, element, index);
3840    if (element.hasFunction()) {
3841      composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1);
3842    }
3843    if (element.hasActor()) {
3844      composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1);
3845    }
3846  }
3847
3848  protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) {
3849    if (element == null) 
3850      return;
3851    Complex t;
3852    if (Utilities.noString(parentType))
3853      t = parent;
3854    else {
3855      t = parent.predicate("fhir:"+parentType+'.'+name);
3856    }
3857    composeDomainResource(t, "ChargeItemDefinition", name, element, index);
3858    if (element.hasUrlElement()) {
3859      composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1);
3860    }
3861    for (int i = 0; i < element.getIdentifier().size(); i++) {
3862      composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i);
3863    }
3864    if (element.hasVersionElement()) {
3865      composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1);
3866    }
3867    if (element.hasTitleElement()) {
3868      composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1);
3869    }
3870    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
3871      composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
3872    }
3873    for (int i = 0; i < element.getPartOf().size(); i++) {
3874      composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i);
3875    }
3876    for (int i = 0; i < element.getReplaces().size(); i++) {
3877      composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i);
3878    }
3879    if (element.hasStatusElement()) {
3880      composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1);
3881    }
3882    if (element.hasExperimentalElement()) {
3883      composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1);
3884    }
3885    if (element.hasDateElement()) {
3886      composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1);
3887    }
3888    if (element.hasPublisherElement()) {
3889      composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1);
3890    }
3891    for (int i = 0; i < element.getContact().size(); i++) {
3892      composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i);
3893    }
3894    if (element.hasDescriptionElement()) {
3895      composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
3896    }
3897    for (int i = 0; i < element.getUseContext().size(); i++) {
3898      composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i);
3899    }
3900    for (int i = 0; i < element.getJurisdiction().size(); i++) {
3901      composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
3902    }
3903    if (element.hasCopyrightElement()) {
3904      composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1);
3905    }
3906    if (element.hasApprovalDateElement()) {
3907      composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1);
3908    }
3909    if (element.hasLastReviewDateElement()) {
3910      composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
3911    }
3912    if (element.hasEffectivePeriod()) {
3913      composePeriod(t, "ChargeItemDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
3914    }
3915    if (element.hasCode()) {
3916      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
3917    }
3918    for (int i = 0; i < element.getInstance().size(); i++) {
3919      composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i);
3920    }
3921    for (int i = 0; i < element.getApplicability().size(); i++) {
3922      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
3923    }
3924    for (int i = 0; i < element.getPropertyGroup().size(); i++) {
3925      composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i);
3926    }
3927  }
3928
3929  protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) {
3930    if (element == null) 
3931      return;
3932    Complex t;
3933    if (Utilities.noString(parentType))
3934      t = parent;
3935    else {
3936      t = parent.predicate("fhir:"+parentType+'.'+name);
3937    }
3938    composeBackboneElement(t, "applicability", name, element, index);
3939    if (element.hasDescriptionElement()) {
3940      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "description", element.getDescriptionElement(), -1);
3941    }
3942    if (element.hasLanguageElement()) {
3943      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "language", element.getLanguageElement(), -1);
3944    }
3945    if (element.hasExpressionElement()) {
3946      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "expression", element.getExpressionElement(), -1);
3947    }
3948  }
3949
3950  protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) {
3951    if (element == null) 
3952      return;
3953    Complex t;
3954    if (Utilities.noString(parentType))
3955      t = parent;
3956    else {
3957      t = parent.predicate("fhir:"+parentType+'.'+name);
3958    }
3959    composeBackboneElement(t, "propertyGroup", name, element, index);
3960    for (int i = 0; i < element.getApplicability().size(); i++) {
3961      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i);
3962    }
3963    for (int i = 0; i < element.getPriceComponent().size(); i++) {
3964      composeChargeItemDefinitionPropertyGroupPriceComponentComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i);
3965    }
3966  }
3967
3968  protected void composeChargeItemDefinitionPropertyGroupPriceComponentComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupPriceComponentComponent element, int index) {
3969    if (element == null) 
3970      return;
3971    Complex t;
3972    if (Utilities.noString(parentType))
3973      t = parent;
3974    else {
3975      t = parent.predicate("fhir:"+parentType+'.'+name);
3976    }
3977    composeBackboneElement(t, "priceComponent", name, element, index);
3978    if (element.hasTypeElement()) {
3979      composeEnum(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "type", element.getTypeElement(), -1);
3980    }
3981    if (element.hasCode()) {
3982      composeCodeableConcept(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "code", element.getCode(), -1);
3983    }
3984    if (element.hasFactorElement()) {
3985      composeDecimal(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "factor", element.getFactorElement(), -1);
3986    }
3987    if (element.hasAmount()) {
3988      composeMoney(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "amount", element.getAmount(), -1);
3989    }
3990  }
3991
3992  protected void composeCitation(Complex parent, String parentType, String name, Citation element, int index) {
3993    if (element == null) 
3994      return;
3995    Complex t;
3996    if (Utilities.noString(parentType))
3997      t = parent;
3998    else {
3999      t = parent.predicate("fhir:"+parentType+'.'+name);
4000    }
4001    composeDomainResource(t, "Citation", name, element, index);
4002    if (element.hasUrlElement()) {
4003      composeUri(t, "Citation", "url", element.getUrlElement(), -1);
4004    }
4005    for (int i = 0; i < element.getIdentifier().size(); i++) {
4006      composeIdentifier(t, "Citation", "identifier", element.getIdentifier().get(i), i);
4007    }
4008    if (element.hasVersionElement()) {
4009      composeString(t, "Citation", "version", element.getVersionElement(), -1);
4010    }
4011    if (element.hasNameElement()) {
4012      composeString(t, "Citation", "name", element.getNameElement(), -1);
4013    }
4014    if (element.hasTitleElement()) {
4015      composeString(t, "Citation", "title", element.getTitleElement(), -1);
4016    }
4017    if (element.hasStatusElement()) {
4018      composeEnum(t, "Citation", "status", element.getStatusElement(), -1);
4019    }
4020    if (element.hasExperimentalElement()) {
4021      composeBoolean(t, "Citation", "experimental", element.getExperimentalElement(), -1);
4022    }
4023    if (element.hasDateElement()) {
4024      composeDateTime(t, "Citation", "date", element.getDateElement(), -1);
4025    }
4026    if (element.hasPublisherElement()) {
4027      composeString(t, "Citation", "publisher", element.getPublisherElement(), -1);
4028    }
4029    for (int i = 0; i < element.getContact().size(); i++) {
4030      composeContactDetail(t, "Citation", "contact", element.getContact().get(i), i);
4031    }
4032    if (element.hasDescriptionElement()) {
4033      composeMarkdown(t, "Citation", "description", element.getDescriptionElement(), -1);
4034    }
4035    for (int i = 0; i < element.getUseContext().size(); i++) {
4036      composeUsageContext(t, "Citation", "useContext", element.getUseContext().get(i), i);
4037    }
4038    for (int i = 0; i < element.getJurisdiction().size(); i++) {
4039      composeCodeableConcept(t, "Citation", "jurisdiction", element.getJurisdiction().get(i), i);
4040    }
4041    if (element.hasPurposeElement()) {
4042      composeMarkdown(t, "Citation", "purpose", element.getPurposeElement(), -1);
4043    }
4044    if (element.hasCopyrightElement()) {
4045      composeMarkdown(t, "Citation", "copyright", element.getCopyrightElement(), -1);
4046    }
4047    if (element.hasApprovalDateElement()) {
4048      composeDate(t, "Citation", "approvalDate", element.getApprovalDateElement(), -1);
4049    }
4050    if (element.hasLastReviewDateElement()) {
4051      composeDate(t, "Citation", "lastReviewDate", element.getLastReviewDateElement(), -1);
4052    }
4053    if (element.hasEffectivePeriod()) {
4054      composePeriod(t, "Citation", "effectivePeriod", element.getEffectivePeriod(), -1);
4055    }
4056    for (int i = 0; i < element.getAuthor().size(); i++) {
4057      composeContactDetail(t, "Citation", "author", element.getAuthor().get(i), i);
4058    }
4059    for (int i = 0; i < element.getEditor().size(); i++) {
4060      composeContactDetail(t, "Citation", "editor", element.getEditor().get(i), i);
4061    }
4062    for (int i = 0; i < element.getReviewer().size(); i++) {
4063      composeContactDetail(t, "Citation", "reviewer", element.getReviewer().get(i), i);
4064    }
4065    for (int i = 0; i < element.getEndorser().size(); i++) {
4066      composeContactDetail(t, "Citation", "endorser", element.getEndorser().get(i), i);
4067    }
4068    for (int i = 0; i < element.getSummary().size(); i++) {
4069      composeContactDetail(t, "Citation", "summary", element.getSummary().get(i), i);
4070    }
4071    for (int i = 0; i < element.getClassification().size(); i++) {
4072      composeCitationClassificationComponent(t, "Citation", "classification", element.getClassification().get(i), i);
4073    }
4074    for (int i = 0; i < element.getNote().size(); i++) {
4075      composeAnnotation(t, "Citation", "note", element.getNote().get(i), i);
4076    }
4077    for (int i = 0; i < element.getCurrentState().size(); i++) {
4078      composeCodeableConcept(t, "Citation", "currentState", element.getCurrentState().get(i), i);
4079    }
4080    for (int i = 0; i < element.getStatusDate().size(); i++) {
4081      composeCitationStatusDateComponent(t, "Citation", "statusDate", element.getStatusDate().get(i), i);
4082    }
4083    for (int i = 0; i < element.getRelatesTo().size(); i++) {
4084      composeCitationRelatesToComponent(t, "Citation", "relatesTo", element.getRelatesTo().get(i), i);
4085    }
4086    if (element.hasCitedArtifact()) {
4087      composeCitationCitedArtifactComponent(t, "Citation", "citedArtifact", element.getCitedArtifact(), -1);
4088    }
4089  }
4090
4091  protected void composeCitationClassificationComponent(Complex parent, String parentType, String name, Citation.CitationClassificationComponent element, int index) {
4092    if (element == null) 
4093      return;
4094    Complex t;
4095    if (Utilities.noString(parentType))
4096      t = parent;
4097    else {
4098      t = parent.predicate("fhir:"+parentType+'.'+name);
4099    }
4100    composeBackboneElement(t, "classification", name, element, index);
4101    if (element.hasType()) {
4102      composeCodeableConcept(t, "CitationClassificationComponent", "type", element.getType(), -1);
4103    }
4104    for (int i = 0; i < element.getClassifier().size(); i++) {
4105      composeCodeableConcept(t, "CitationClassificationComponent", "classifier", element.getClassifier().get(i), i);
4106    }
4107  }
4108
4109  protected void composeCitationStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationStatusDateComponent element, int index) {
4110    if (element == null) 
4111      return;
4112    Complex t;
4113    if (Utilities.noString(parentType))
4114      t = parent;
4115    else {
4116      t = parent.predicate("fhir:"+parentType+'.'+name);
4117    }
4118    composeBackboneElement(t, "statusDate", name, element, index);
4119    if (element.hasActivity()) {
4120      composeCodeableConcept(t, "CitationStatusDateComponent", "activity", element.getActivity(), -1);
4121    }
4122    if (element.hasActualElement()) {
4123      composeBoolean(t, "CitationStatusDateComponent", "actual", element.getActualElement(), -1);
4124    }
4125    if (element.hasPeriod()) {
4126      composePeriod(t, "CitationStatusDateComponent", "period", element.getPeriod(), -1);
4127    }
4128  }
4129
4130  protected void composeCitationRelatesToComponent(Complex parent, String parentType, String name, Citation.CitationRelatesToComponent element, int index) {
4131    if (element == null) 
4132      return;
4133    Complex t;
4134    if (Utilities.noString(parentType))
4135      t = parent;
4136    else {
4137      t = parent.predicate("fhir:"+parentType+'.'+name);
4138    }
4139    composeBackboneElement(t, "relatesTo", name, element, index);
4140    if (element.hasRelationshipType()) {
4141      composeCodeableConcept(t, "CitationRelatesToComponent", "relationshipType", element.getRelationshipType(), -1);
4142    }
4143    for (int i = 0; i < element.getTargetClassifier().size(); i++) {
4144      composeCodeableConcept(t, "CitationRelatesToComponent", "targetClassifier", element.getTargetClassifier().get(i), i);
4145    }
4146    if (element.hasTarget()) {
4147      composeType(t, "CitationRelatesToComponent", "target", element.getTarget(), -1);
4148    }
4149  }
4150
4151  protected void composeCitationCitedArtifactComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactComponent element, int index) {
4152    if (element == null) 
4153      return;
4154    Complex t;
4155    if (Utilities.noString(parentType))
4156      t = parent;
4157    else {
4158      t = parent.predicate("fhir:"+parentType+'.'+name);
4159    }
4160    composeBackboneElement(t, "citedArtifact", name, element, index);
4161    for (int i = 0; i < element.getIdentifier().size(); i++) {
4162      composeIdentifier(t, "CitationCitedArtifactComponent", "identifier", element.getIdentifier().get(i), i);
4163    }
4164    for (int i = 0; i < element.getRelatedIdentifier().size(); i++) {
4165      composeIdentifier(t, "CitationCitedArtifactComponent", "relatedIdentifier", element.getRelatedIdentifier().get(i), i);
4166    }
4167    if (element.hasDateAccessedElement()) {
4168      composeDateTime(t, "CitationCitedArtifactComponent", "dateAccessed", element.getDateAccessedElement(), -1);
4169    }
4170    if (element.hasVersion()) {
4171      composeCitationCitedArtifactVersionComponent(t, "CitationCitedArtifactComponent", "version", element.getVersion(), -1);
4172    }
4173    for (int i = 0; i < element.getCurrentState().size(); i++) {
4174      composeCodeableConcept(t, "CitationCitedArtifactComponent", "currentState", element.getCurrentState().get(i), i);
4175    }
4176    for (int i = 0; i < element.getStatusDate().size(); i++) {
4177      composeCitationCitedArtifactStatusDateComponent(t, "CitationCitedArtifactComponent", "statusDate", element.getStatusDate().get(i), i);
4178    }
4179    for (int i = 0; i < element.getTitle().size(); i++) {
4180      composeCitationCitedArtifactTitleComponent(t, "CitationCitedArtifactComponent", "title", element.getTitle().get(i), i);
4181    }
4182    for (int i = 0; i < element.getAbstract().size(); i++) {
4183      composeCitationCitedArtifactAbstractComponent(t, "CitationCitedArtifactComponent", "abstract", element.getAbstract().get(i), i);
4184    }
4185    if (element.hasPart()) {
4186      composeCitationCitedArtifactPartComponent(t, "CitationCitedArtifactComponent", "part", element.getPart(), -1);
4187    }
4188    for (int i = 0; i < element.getRelatesTo().size(); i++) {
4189      composeCitationCitedArtifactRelatesToComponent(t, "CitationCitedArtifactComponent", "relatesTo", element.getRelatesTo().get(i), i);
4190    }
4191    for (int i = 0; i < element.getPublicationForm().size(); i++) {
4192      composeCitationCitedArtifactPublicationFormComponent(t, "CitationCitedArtifactComponent", "publicationForm", element.getPublicationForm().get(i), i);
4193    }
4194    for (int i = 0; i < element.getWebLocation().size(); i++) {
4195      composeCitationCitedArtifactWebLocationComponent(t, "CitationCitedArtifactComponent", "webLocation", element.getWebLocation().get(i), i);
4196    }
4197    for (int i = 0; i < element.getClassification().size(); i++) {
4198      composeCitationCitedArtifactClassificationComponent(t, "CitationCitedArtifactComponent", "classification", element.getClassification().get(i), i);
4199    }
4200    if (element.hasContributorship()) {
4201      composeCitationCitedArtifactContributorshipComponent(t, "CitationCitedArtifactComponent", "contributorship", element.getContributorship(), -1);
4202    }
4203    for (int i = 0; i < element.getNote().size(); i++) {
4204      composeAnnotation(t, "CitationCitedArtifactComponent", "note", element.getNote().get(i), i);
4205    }
4206  }
4207
4208  protected void composeCitationCitedArtifactVersionComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactVersionComponent element, int index) {
4209    if (element == null) 
4210      return;
4211    Complex t;
4212    if (Utilities.noString(parentType))
4213      t = parent;
4214    else {
4215      t = parent.predicate("fhir:"+parentType+'.'+name);
4216    }
4217    composeBackboneElement(t, "version", name, element, index);
4218    if (element.hasValueElement()) {
4219      composeString(t, "CitationCitedArtifactVersionComponent", "value", element.getValueElement(), -1);
4220    }
4221    if (element.hasBaseCitation()) {
4222      composeReference(t, "CitationCitedArtifactVersionComponent", "baseCitation", element.getBaseCitation(), -1);
4223    }
4224  }
4225
4226  protected void composeCitationCitedArtifactStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactStatusDateComponent element, int index) {
4227    if (element == null) 
4228      return;
4229    Complex t;
4230    if (Utilities.noString(parentType))
4231      t = parent;
4232    else {
4233      t = parent.predicate("fhir:"+parentType+'.'+name);
4234    }
4235    composeBackboneElement(t, "statusDate", name, element, index);
4236    if (element.hasActivity()) {
4237      composeCodeableConcept(t, "CitationCitedArtifactStatusDateComponent", "activity", element.getActivity(), -1);
4238    }
4239    if (element.hasActualElement()) {
4240      composeBoolean(t, "CitationCitedArtifactStatusDateComponent", "actual", element.getActualElement(), -1);
4241    }
4242    if (element.hasPeriod()) {
4243      composePeriod(t, "CitationCitedArtifactStatusDateComponent", "period", element.getPeriod(), -1);
4244    }
4245  }
4246
4247  protected void composeCitationCitedArtifactTitleComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactTitleComponent element, int index) {
4248    if (element == null) 
4249      return;
4250    Complex t;
4251    if (Utilities.noString(parentType))
4252      t = parent;
4253    else {
4254      t = parent.predicate("fhir:"+parentType+'.'+name);
4255    }
4256    composeBackboneElement(t, "title", name, element, index);
4257    for (int i = 0; i < element.getType().size(); i++) {
4258      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "type", element.getType().get(i), i);
4259    }
4260    if (element.hasLanguage()) {
4261      composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "language", element.getLanguage(), -1);
4262    }
4263    if (element.hasTextElement()) {
4264      composeMarkdown(t, "CitationCitedArtifactTitleComponent", "text", element.getTextElement(), -1);
4265    }
4266  }
4267
4268  protected void composeCitationCitedArtifactAbstractComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactAbstractComponent element, int index) {
4269    if (element == null) 
4270      return;
4271    Complex t;
4272    if (Utilities.noString(parentType))
4273      t = parent;
4274    else {
4275      t = parent.predicate("fhir:"+parentType+'.'+name);
4276    }
4277    composeBackboneElement(t, "abstract", name, element, index);
4278    if (element.hasType()) {
4279      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "type", element.getType(), -1);
4280    }
4281    if (element.hasLanguage()) {
4282      composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "language", element.getLanguage(), -1);
4283    }
4284    if (element.hasTextElement()) {
4285      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "text", element.getTextElement(), -1);
4286    }
4287    if (element.hasCopyrightElement()) {
4288      composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "copyright", element.getCopyrightElement(), -1);
4289    }
4290  }
4291
4292  protected void composeCitationCitedArtifactPartComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPartComponent element, int index) {
4293    if (element == null) 
4294      return;
4295    Complex t;
4296    if (Utilities.noString(parentType))
4297      t = parent;
4298    else {
4299      t = parent.predicate("fhir:"+parentType+'.'+name);
4300    }
4301    composeBackboneElement(t, "part", name, element, index);
4302    if (element.hasType()) {
4303      composeCodeableConcept(t, "CitationCitedArtifactPartComponent", "type", element.getType(), -1);
4304    }
4305    if (element.hasValueElement()) {
4306      composeString(t, "CitationCitedArtifactPartComponent", "value", element.getValueElement(), -1);
4307    }
4308    if (element.hasBaseCitation()) {
4309      composeReference(t, "CitationCitedArtifactPartComponent", "baseCitation", element.getBaseCitation(), -1);
4310    }
4311  }
4312
4313  protected void composeCitationCitedArtifactRelatesToComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactRelatesToComponent element, int index) {
4314    if (element == null) 
4315      return;
4316    Complex t;
4317    if (Utilities.noString(parentType))
4318      t = parent;
4319    else {
4320      t = parent.predicate("fhir:"+parentType+'.'+name);
4321    }
4322    composeBackboneElement(t, "relatesTo", name, element, index);
4323    if (element.hasRelationshipType()) {
4324      composeCodeableConcept(t, "CitationCitedArtifactRelatesToComponent", "relationshipType", element.getRelationshipType(), -1);
4325    }
4326    for (int i = 0; i < element.getTargetClassifier().size(); i++) {
4327      composeCodeableConcept(t, "CitationCitedArtifactRelatesToComponent", "targetClassifier", element.getTargetClassifier().get(i), i);
4328    }
4329    if (element.hasTarget()) {
4330      composeType(t, "CitationCitedArtifactRelatesToComponent", "target", element.getTarget(), -1);
4331    }
4332  }
4333
4334  protected void composeCitationCitedArtifactPublicationFormComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormComponent element, int index) {
4335    if (element == null) 
4336      return;
4337    Complex t;
4338    if (Utilities.noString(parentType))
4339      t = parent;
4340    else {
4341      t = parent.predicate("fhir:"+parentType+'.'+name);
4342    }
4343    composeBackboneElement(t, "publicationForm", name, element, index);
4344    if (element.hasPublishedIn()) {
4345      composeCitationCitedArtifactPublicationFormPublishedInComponent(t, "CitationCitedArtifactPublicationFormComponent", "publishedIn", element.getPublishedIn(), -1);
4346    }
4347    if (element.hasPeriodicRelease()) {
4348      composeCitationCitedArtifactPublicationFormPeriodicReleaseComponent(t, "CitationCitedArtifactPublicationFormComponent", "periodicRelease", element.getPeriodicRelease(), -1);
4349    }
4350    if (element.hasArticleDateElement()) {
4351      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "articleDate", element.getArticleDateElement(), -1);
4352    }
4353    if (element.hasLastRevisionDateElement()) {
4354      composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "lastRevisionDate", element.getLastRevisionDateElement(), -1);
4355    }
4356    for (int i = 0; i < element.getLanguage().size(); i++) {
4357      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "language", element.getLanguage().get(i), i);
4358    }
4359    if (element.hasAccessionNumberElement()) {
4360      composeString(t, "CitationCitedArtifactPublicationFormComponent", "accessionNumber", element.getAccessionNumberElement(), -1);
4361    }
4362    if (element.hasPageStringElement()) {
4363      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageString", element.getPageStringElement(), -1);
4364    }
4365    if (element.hasFirstPageElement()) {
4366      composeString(t, "CitationCitedArtifactPublicationFormComponent", "firstPage", element.getFirstPageElement(), -1);
4367    }
4368    if (element.hasLastPageElement()) {
4369      composeString(t, "CitationCitedArtifactPublicationFormComponent", "lastPage", element.getLastPageElement(), -1);
4370    }
4371    if (element.hasPageCountElement()) {
4372      composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageCount", element.getPageCountElement(), -1);
4373    }
4374    if (element.hasCopyrightElement()) {
4375      composeMarkdown(t, "CitationCitedArtifactPublicationFormComponent", "copyright", element.getCopyrightElement(), -1);
4376    }
4377  }
4378
4379  protected void composeCitationCitedArtifactPublicationFormPublishedInComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPublishedInComponent element, int index) {
4380    if (element == null) 
4381      return;
4382    Complex t;
4383    if (Utilities.noString(parentType))
4384      t = parent;
4385    else {
4386      t = parent.predicate("fhir:"+parentType+'.'+name);
4387    }
4388    composeBackboneElement(t, "publishedIn", name, element, index);
4389    if (element.hasType()) {
4390      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "type", element.getType(), -1);
4391    }
4392    for (int i = 0; i < element.getIdentifier().size(); i++) {
4393      composeIdentifier(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "identifier", element.getIdentifier().get(i), i);
4394    }
4395    if (element.hasTitleElement()) {
4396      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "title", element.getTitleElement(), -1);
4397    }
4398    if (element.hasPublisher()) {
4399      composeReference(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisher", element.getPublisher(), -1);
4400    }
4401    if (element.hasPublisherLocationElement()) {
4402      composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisherLocation", element.getPublisherLocationElement(), -1);
4403    }
4404  }
4405
4406  protected void composeCitationCitedArtifactPublicationFormPeriodicReleaseComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPeriodicReleaseComponent element, int index) {
4407    if (element == null) 
4408      return;
4409    Complex t;
4410    if (Utilities.noString(parentType))
4411      t = parent;
4412    else {
4413      t = parent.predicate("fhir:"+parentType+'.'+name);
4414    }
4415    composeBackboneElement(t, "periodicRelease", name, element, index);
4416    if (element.hasCitedMedium()) {
4417      composeCodeableConcept(t, "CitationCitedArtifactPublicationFormPeriodicReleaseComponent", "citedMedium", element.getCitedMedium(), -1);
4418    }
4419    if (element.hasVolumeElement()) {
4420      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseComponent", "volume", element.getVolumeElement(), -1);
4421    }
4422    if (element.hasIssueElement()) {
4423      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseComponent", "issue", element.getIssueElement(), -1);
4424    }
4425    if (element.hasDateOfPublication()) {
4426      composeCitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent(t, "CitationCitedArtifactPublicationFormPeriodicReleaseComponent", "dateOfPublication", element.getDateOfPublication(), -1);
4427    }
4428  }
4429
4430  protected void composeCitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent element, int index) {
4431    if (element == null) 
4432      return;
4433    Complex t;
4434    if (Utilities.noString(parentType))
4435      t = parent;
4436    else {
4437      t = parent.predicate("fhir:"+parentType+'.'+name);
4438    }
4439    composeBackboneElement(t, "dateOfPublication", name, element, index);
4440    if (element.hasDateElement()) {
4441      composeDate(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "date", element.getDateElement(), -1);
4442    }
4443    if (element.hasYearElement()) {
4444      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "year", element.getYearElement(), -1);
4445    }
4446    if (element.hasMonthElement()) {
4447      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "month", element.getMonthElement(), -1);
4448    }
4449    if (element.hasDayElement()) {
4450      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "day", element.getDayElement(), -1);
4451    }
4452    if (element.hasSeasonElement()) {
4453      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "season", element.getSeasonElement(), -1);
4454    }
4455    if (element.hasTextElement()) {
4456      composeString(t, "CitationCitedArtifactPublicationFormPeriodicReleaseDateOfPublicationComponent", "text", element.getTextElement(), -1);
4457    }
4458  }
4459
4460  protected void composeCitationCitedArtifactWebLocationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactWebLocationComponent element, int index) {
4461    if (element == null) 
4462      return;
4463    Complex t;
4464    if (Utilities.noString(parentType))
4465      t = parent;
4466    else {
4467      t = parent.predicate("fhir:"+parentType+'.'+name);
4468    }
4469    composeBackboneElement(t, "webLocation", name, element, index);
4470    if (element.hasType()) {
4471      composeCodeableConcept(t, "CitationCitedArtifactWebLocationComponent", "type", element.getType(), -1);
4472    }
4473    if (element.hasUrlElement()) {
4474      composeUri(t, "CitationCitedArtifactWebLocationComponent", "url", element.getUrlElement(), -1);
4475    }
4476  }
4477
4478  protected void composeCitationCitedArtifactClassificationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactClassificationComponent element, int index) {
4479    if (element == null) 
4480      return;
4481    Complex t;
4482    if (Utilities.noString(parentType))
4483      t = parent;
4484    else {
4485      t = parent.predicate("fhir:"+parentType+'.'+name);
4486    }
4487    composeBackboneElement(t, "classification", name, element, index);
4488    if (element.hasType()) {
4489      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "type", element.getType(), -1);
4490    }
4491    for (int i = 0; i < element.getClassifier().size(); i++) {
4492      composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "classifier", element.getClassifier().get(i), i);
4493    }
4494    if (element.hasWhoClassified()) {
4495      composeCitationCitedArtifactClassificationWhoClassifiedComponent(t, "CitationCitedArtifactClassificationComponent", "whoClassified", element.getWhoClassified(), -1);
4496    }
4497  }
4498
4499  protected void composeCitationCitedArtifactClassificationWhoClassifiedComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactClassificationWhoClassifiedComponent element, int index) {
4500    if (element == null) 
4501      return;
4502    Complex t;
4503    if (Utilities.noString(parentType))
4504      t = parent;
4505    else {
4506      t = parent.predicate("fhir:"+parentType+'.'+name);
4507    }
4508    composeBackboneElement(t, "whoClassified", name, element, index);
4509    if (element.hasPerson()) {
4510      composeReference(t, "CitationCitedArtifactClassificationWhoClassifiedComponent", "person", element.getPerson(), -1);
4511    }
4512    if (element.hasOrganization()) {
4513      composeReference(t, "CitationCitedArtifactClassificationWhoClassifiedComponent", "organization", element.getOrganization(), -1);
4514    }
4515    if (element.hasPublisher()) {
4516      composeReference(t, "CitationCitedArtifactClassificationWhoClassifiedComponent", "publisher", element.getPublisher(), -1);
4517    }
4518    if (element.hasClassifierCopyrightElement()) {
4519      composeString(t, "CitationCitedArtifactClassificationWhoClassifiedComponent", "classifierCopyright", element.getClassifierCopyrightElement(), -1);
4520    }
4521    if (element.hasFreeToShareElement()) {
4522      composeBoolean(t, "CitationCitedArtifactClassificationWhoClassifiedComponent", "freeToShare", element.getFreeToShareElement(), -1);
4523    }
4524  }
4525
4526  protected void composeCitationCitedArtifactContributorshipComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipComponent element, int index) {
4527    if (element == null) 
4528      return;
4529    Complex t;
4530    if (Utilities.noString(parentType))
4531      t = parent;
4532    else {
4533      t = parent.predicate("fhir:"+parentType+'.'+name);
4534    }
4535    composeBackboneElement(t, "contributorship", name, element, index);
4536    if (element.hasCompleteElement()) {
4537      composeBoolean(t, "CitationCitedArtifactContributorshipComponent", "complete", element.getCompleteElement(), -1);
4538    }
4539    for (int i = 0; i < element.getEntry().size(); i++) {
4540      composeCitationCitedArtifactContributorshipEntryComponent(t, "CitationCitedArtifactContributorshipComponent", "entry", element.getEntry().get(i), i);
4541    }
4542    for (int i = 0; i < element.getSummary().size(); i++) {
4543      composeCitationCitedArtifactContributorshipSummaryComponent(t, "CitationCitedArtifactContributorshipComponent", "summary", element.getSummary().get(i), i);
4544    }
4545  }
4546
4547  protected void composeCitationCitedArtifactContributorshipEntryComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryComponent element, int index) {
4548    if (element == null) 
4549      return;
4550    Complex t;
4551    if (Utilities.noString(parentType))
4552      t = parent;
4553    else {
4554      t = parent.predicate("fhir:"+parentType+'.'+name);
4555    }
4556    composeBackboneElement(t, "entry", name, element, index);
4557    if (element.hasName()) {
4558      composeHumanName(t, "CitationCitedArtifactContributorshipEntryComponent", "name", element.getName(), -1);
4559    }
4560    if (element.hasInitialsElement()) {
4561      composeString(t, "CitationCitedArtifactContributorshipEntryComponent", "initials", element.getInitialsElement(), -1);
4562    }
4563    if (element.hasCollectiveNameElement()) {
4564      composeString(t, "CitationCitedArtifactContributorshipEntryComponent", "collectiveName", element.getCollectiveNameElement(), -1);
4565    }
4566    for (int i = 0; i < element.getIdentifier().size(); i++) {
4567      composeIdentifier(t, "CitationCitedArtifactContributorshipEntryComponent", "identifier", element.getIdentifier().get(i), i);
4568    }
4569    for (int i = 0; i < element.getAffiliationInfo().size(); i++) {
4570      composeCitationCitedArtifactContributorshipEntryAffiliationInfoComponent(t, "CitationCitedArtifactContributorshipEntryComponent", "affiliationInfo", element.getAffiliationInfo().get(i), i);
4571    }
4572    for (int i = 0; i < element.getAddress().size(); i++) {
4573      composeAddress(t, "CitationCitedArtifactContributorshipEntryComponent", "address", element.getAddress().get(i), i);
4574    }
4575    for (int i = 0; i < element.getTelecom().size(); i++) {
4576      composeContactPoint(t, "CitationCitedArtifactContributorshipEntryComponent", "telecom", element.getTelecom().get(i), i);
4577    }
4578    for (int i = 0; i < element.getContributionType().size(); i++) {
4579      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionType", element.getContributionType().get(i), i);
4580    }
4581    if (element.hasRole()) {
4582      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "role", element.getRole(), -1);
4583    }
4584    for (int i = 0; i < element.getContributionInstance().size(); i++) {
4585      composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionInstance", element.getContributionInstance().get(i), i);
4586    }
4587    if (element.hasCorrespondingContactElement()) {
4588      composeBoolean(t, "CitationCitedArtifactContributorshipEntryComponent", "correspondingContact", element.getCorrespondingContactElement(), -1);
4589    }
4590    if (element.hasListOrderElement()) {
4591      composePositiveInt(t, "CitationCitedArtifactContributorshipEntryComponent", "listOrder", element.getListOrderElement(), -1);
4592    }
4593  }
4594
4595  protected void composeCitationCitedArtifactContributorshipEntryAffiliationInfoComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryAffiliationInfoComponent element, int index) {
4596    if (element == null) 
4597      return;
4598    Complex t;
4599    if (Utilities.noString(parentType))
4600      t = parent;
4601    else {
4602      t = parent.predicate("fhir:"+parentType+'.'+name);
4603    }
4604    composeBackboneElement(t, "affiliationInfo", name, element, index);
4605    if (element.hasAffiliationElement()) {
4606      composeString(t, "CitationCitedArtifactContributorshipEntryAffiliationInfoComponent", "affiliation", element.getAffiliationElement(), -1);
4607    }
4608    if (element.hasRoleElement()) {
4609      composeString(t, "CitationCitedArtifactContributorshipEntryAffiliationInfoComponent", "role", element.getRoleElement(), -1);
4610    }
4611    for (int i = 0; i < element.getIdentifier().size(); i++) {
4612      composeIdentifier(t, "CitationCitedArtifactContributorshipEntryAffiliationInfoComponent", "identifier", element.getIdentifier().get(i), i);
4613    }
4614  }
4615
4616  protected void composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent element, int index) {
4617    if (element == null) 
4618      return;
4619    Complex t;
4620    if (Utilities.noString(parentType))
4621      t = parent;
4622    else {
4623      t = parent.predicate("fhir:"+parentType+'.'+name);
4624    }
4625    composeBackboneElement(t, "contributionInstance", name, element, index);
4626    if (element.hasType()) {
4627      composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "type", element.getType(), -1);
4628    }
4629    if (element.hasTimeElement()) {
4630      composeDateTime(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "time", element.getTimeElement(), -1);
4631    }
4632  }
4633
4634  protected void composeCitationCitedArtifactContributorshipSummaryComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipSummaryComponent element, int index) {
4635    if (element == null) 
4636      return;
4637    Complex t;
4638    if (Utilities.noString(parentType))
4639      t = parent;
4640    else {
4641      t = parent.predicate("fhir:"+parentType+'.'+name);
4642    }
4643    composeBackboneElement(t, "summary", name, element, index);
4644    if (element.hasType()) {
4645      composeCodeableConcept(t, "CitationCitedArtifactContributorshipSummaryComponent", "type", element.getType(), -1);
4646    }
4647    if (element.hasStyle()) {
4648      composeCodeableConcept(t, "CitationCitedArtifactContributorshipSummaryComponent", "style", element.getStyle(), -1);
4649    }
4650    if (element.hasSource()) {
4651      composeCodeableConcept(t, "CitationCitedArtifactContributorshipSummaryComponent", "source", element.getSource(), -1);
4652    }
4653    if (element.hasValueElement()) {
4654      composeMarkdown(t, "CitationCitedArtifactContributorshipSummaryComponent", "value", element.getValueElement(), -1);
4655    }
4656  }
4657
4658  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
4659    if (element == null) 
4660      return;
4661    Complex t;
4662    if (Utilities.noString(parentType))
4663      t = parent;
4664    else {
4665      t = parent.predicate("fhir:"+parentType+'.'+name);
4666    }
4667    composeDomainResource(t, "Claim", name, element, index);
4668    for (int i = 0; i < element.getIdentifier().size(); i++) {
4669      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
4670    }
4671    if (element.hasStatusElement()) {
4672      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
4673    }
4674    if (element.hasType()) {
4675      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
4676    }
4677    if (element.hasSubType()) {
4678      composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1);
4679    }
4680    if (element.hasUseElement()) {
4681      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
4682    }
4683    if (element.hasPatient()) {
4684      composeReference(t, "Claim", "patient", element.getPatient(), -1);
4685    }
4686    if (element.hasBillablePeriod()) {
4687      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
4688    }
4689    if (element.hasCreatedElement()) {
4690      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
4691    }
4692    if (element.hasEnterer()) {
4693      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
4694    }
4695    if (element.hasInsurer()) {
4696      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
4697    }
4698    if (element.hasProvider()) {
4699      composeReference(t, "Claim", "provider", element.getProvider(), -1);
4700    }
4701    if (element.hasPriority()) {
4702      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
4703    }
4704    if (element.hasFundsReserve()) {
4705      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
4706    }
4707    for (int i = 0; i < element.getRelated().size(); i++) {
4708      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
4709    }
4710    if (element.hasPrescription()) {
4711      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
4712    }
4713    if (element.hasOriginalPrescription()) {
4714      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
4715    }
4716    if (element.hasPayee()) {
4717      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
4718    }
4719    if (element.hasReferral()) {
4720      composeReference(t, "Claim", "referral", element.getReferral(), -1);
4721    }
4722    if (element.hasFacility()) {
4723      composeReference(t, "Claim", "facility", element.getFacility(), -1);
4724    }
4725    for (int i = 0; i < element.getCareTeam().size(); i++) {
4726      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
4727    }
4728    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
4729      composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i);
4730    }
4731    for (int i = 0; i < element.getDiagnosis().size(); i++) {
4732      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
4733    }
4734    for (int i = 0; i < element.getProcedure().size(); i++) {
4735      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
4736    }
4737    for (int i = 0; i < element.getInsurance().size(); i++) {
4738      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
4739    }
4740    if (element.hasAccident()) {
4741      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
4742    }
4743    for (int i = 0; i < element.getItem().size(); i++) {
4744      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
4745    }
4746    if (element.hasTotal()) {
4747      composeMoney(t, "Claim", "total", element.getTotal(), -1);
4748    }
4749  }
4750
4751  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) {
4752    if (element == null) 
4753      return;
4754    Complex t;
4755    if (Utilities.noString(parentType))
4756      t = parent;
4757    else {
4758      t = parent.predicate("fhir:"+parentType+'.'+name);
4759    }
4760    composeBackboneElement(t, "related", name, element, index);
4761    if (element.hasClaim()) {
4762      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
4763    }
4764    if (element.hasRelationship()) {
4765      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
4766    }
4767    if (element.hasReference()) {
4768      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
4769    }
4770  }
4771
4772  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
4773    if (element == null) 
4774      return;
4775    Complex t;
4776    if (Utilities.noString(parentType))
4777      t = parent;
4778    else {
4779      t = parent.predicate("fhir:"+parentType+'.'+name);
4780    }
4781    composeBackboneElement(t, "payee", name, element, index);
4782    if (element.hasType()) {
4783      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
4784    }
4785    if (element.hasParty()) {
4786      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
4787    }
4788  }
4789
4790  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) {
4791    if (element == null) 
4792      return;
4793    Complex t;
4794    if (Utilities.noString(parentType))
4795      t = parent;
4796    else {
4797      t = parent.predicate("fhir:"+parentType+'.'+name);
4798    }
4799    composeBackboneElement(t, "careTeam", name, element, index);
4800    if (element.hasSequenceElement()) {
4801      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
4802    }
4803    if (element.hasProvider()) {
4804      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
4805    }
4806    if (element.hasResponsibleElement()) {
4807      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
4808    }
4809    if (element.hasRole()) {
4810      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
4811    }
4812    if (element.hasQualification()) {
4813      composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1);
4814    }
4815  }
4816
4817  protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) {
4818    if (element == null) 
4819      return;
4820    Complex t;
4821    if (Utilities.noString(parentType))
4822      t = parent;
4823    else {
4824      t = parent.predicate("fhir:"+parentType+'.'+name);
4825    }
4826    composeBackboneElement(t, "supportingInfo", name, element, index);
4827    if (element.hasSequenceElement()) {
4828      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
4829    }
4830    if (element.hasCategory()) {
4831      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
4832    }
4833    if (element.hasCode()) {
4834      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
4835    }
4836    if (element.hasTiming()) {
4837      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
4838    }
4839    if (element.hasValue()) {
4840      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
4841    }
4842    if (element.hasReason()) {
4843      composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
4844    }
4845  }
4846
4847  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
4848    if (element == null) 
4849      return;
4850    Complex t;
4851    if (Utilities.noString(parentType))
4852      t = parent;
4853    else {
4854      t = parent.predicate("fhir:"+parentType+'.'+name);
4855    }
4856    composeBackboneElement(t, "diagnosis", name, element, index);
4857    if (element.hasSequenceElement()) {
4858      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
4859    }
4860    if (element.hasDiagnosis()) {
4861      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
4862    }
4863    for (int i = 0; i < element.getType().size(); i++) {
4864      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
4865    }
4866    if (element.hasOnAdmission()) {
4867      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
4868    }
4869    if (element.hasPackageCode()) {
4870      composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1);
4871    }
4872  }
4873
4874  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
4875    if (element == null) 
4876      return;
4877    Complex t;
4878    if (Utilities.noString(parentType))
4879      t = parent;
4880    else {
4881      t = parent.predicate("fhir:"+parentType+'.'+name);
4882    }
4883    composeBackboneElement(t, "procedure", name, element, index);
4884    if (element.hasSequenceElement()) {
4885      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
4886    }
4887    for (int i = 0; i < element.getType().size(); i++) {
4888      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
4889    }
4890    if (element.hasDateElement()) {
4891      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
4892    }
4893    if (element.hasProcedure()) {
4894      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
4895    }
4896    for (int i = 0; i < element.getUdi().size(); i++) {
4897      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
4898    }
4899  }
4900
4901  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
4902    if (element == null) 
4903      return;
4904    Complex t;
4905    if (Utilities.noString(parentType))
4906      t = parent;
4907    else {
4908      t = parent.predicate("fhir:"+parentType+'.'+name);
4909    }
4910    composeBackboneElement(t, "insurance", name, element, index);
4911    if (element.hasSequenceElement()) {
4912      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
4913    }
4914    if (element.hasFocalElement()) {
4915      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
4916    }
4917    if (element.hasIdentifier()) {
4918      composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1);
4919    }
4920    if (element.hasCoverage()) {
4921      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
4922    }
4923    if (element.hasBusinessArrangementElement()) {
4924      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
4925    }
4926    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
4927      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
4928    }
4929    if (element.hasClaimResponse()) {
4930      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
4931    }
4932  }
4933
4934  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
4935    if (element == null) 
4936      return;
4937    Complex t;
4938    if (Utilities.noString(parentType))
4939      t = parent;
4940    else {
4941      t = parent.predicate("fhir:"+parentType+'.'+name);
4942    }
4943    composeBackboneElement(t, "accident", name, element, index);
4944    if (element.hasDateElement()) {
4945      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
4946    }
4947    if (element.hasType()) {
4948      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
4949    }
4950    if (element.hasLocation()) {
4951      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
4952    }
4953  }
4954
4955  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) {
4956    if (element == null) 
4957      return;
4958    Complex t;
4959    if (Utilities.noString(parentType))
4960      t = parent;
4961    else {
4962      t = parent.predicate("fhir:"+parentType+'.'+name);
4963    }
4964    composeBackboneElement(t, "item", name, element, index);
4965    if (element.hasSequenceElement()) {
4966      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
4967    }
4968    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
4969      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
4970    }
4971    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
4972      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
4973    }
4974    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
4975      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
4976    }
4977    for (int i = 0; i < element.getInformationSequence().size(); i++) {
4978      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
4979    }
4980    if (element.hasRevenue()) {
4981      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
4982    }
4983    if (element.hasCategory()) {
4984      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
4985    }
4986    if (element.hasProductOrService()) {
4987      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
4988    }
4989    for (int i = 0; i < element.getModifier().size(); i++) {
4990      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
4991    }
4992    for (int i = 0; i < element.getProgramCode().size(); i++) {
4993      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
4994    }
4995    if (element.hasServiced()) {
4996      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
4997    }
4998    if (element.hasLocation()) {
4999      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
5000    }
5001    if (element.hasQuantity()) {
5002      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
5003    }
5004    if (element.hasUnitPrice()) {
5005      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
5006    }
5007    if (element.hasFactorElement()) {
5008      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
5009    }
5010    if (element.hasNet()) {
5011      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
5012    }
5013    for (int i = 0; i < element.getUdi().size(); i++) {
5014      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
5015    }
5016    if (element.hasBodySite()) {
5017      composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1);
5018    }
5019    for (int i = 0; i < element.getSubSite().size(); i++) {
5020      composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i);
5021    }
5022    for (int i = 0; i < element.getEncounter().size(); i++) {
5023      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
5024    }
5025    for (int i = 0; i < element.getDetail().size(); i++) {
5026      composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
5027    }
5028  }
5029
5030  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
5031    if (element == null) 
5032      return;
5033    Complex t;
5034    if (Utilities.noString(parentType))
5035      t = parent;
5036    else {
5037      t = parent.predicate("fhir:"+parentType+'.'+name);
5038    }
5039    composeBackboneElement(t, "detail", name, element, index);
5040    if (element.hasSequenceElement()) {
5041      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
5042    }
5043    if (element.hasRevenue()) {
5044      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
5045    }
5046    if (element.hasCategory()) {
5047      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
5048    }
5049    if (element.hasProductOrService()) {
5050      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
5051    }
5052    for (int i = 0; i < element.getModifier().size(); i++) {
5053      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
5054    }
5055    for (int i = 0; i < element.getProgramCode().size(); i++) {
5056      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
5057    }
5058    if (element.hasQuantity()) {
5059      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
5060    }
5061    if (element.hasUnitPrice()) {
5062      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
5063    }
5064    if (element.hasFactorElement()) {
5065      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
5066    }
5067    if (element.hasNet()) {
5068      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
5069    }
5070    for (int i = 0; i < element.getUdi().size(); i++) {
5071      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
5072    }
5073    for (int i = 0; i < element.getSubDetail().size(); i++) {
5074      composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
5075    }
5076  }
5077
5078  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
5079    if (element == null) 
5080      return;
5081    Complex t;
5082    if (Utilities.noString(parentType))
5083      t = parent;
5084    else {
5085      t = parent.predicate("fhir:"+parentType+'.'+name);
5086    }
5087    composeBackboneElement(t, "subDetail", name, element, index);
5088    if (element.hasSequenceElement()) {
5089      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
5090    }
5091    if (element.hasRevenue()) {
5092      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
5093    }
5094    if (element.hasCategory()) {
5095      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
5096    }
5097    if (element.hasProductOrService()) {
5098      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
5099    }
5100    for (int i = 0; i < element.getModifier().size(); i++) {
5101      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
5102    }
5103    for (int i = 0; i < element.getProgramCode().size(); i++) {
5104      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
5105    }
5106    if (element.hasQuantity()) {
5107      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
5108    }
5109    if (element.hasUnitPrice()) {
5110      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5111    }
5112    if (element.hasFactorElement()) {
5113      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
5114    }
5115    if (element.hasNet()) {
5116      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
5117    }
5118    for (int i = 0; i < element.getUdi().size(); i++) {
5119      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
5120    }
5121  }
5122
5123  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
5124    if (element == null) 
5125      return;
5126    Complex t;
5127    if (Utilities.noString(parentType))
5128      t = parent;
5129    else {
5130      t = parent.predicate("fhir:"+parentType+'.'+name);
5131    }
5132    composeDomainResource(t, "ClaimResponse", name, element, index);
5133    for (int i = 0; i < element.getIdentifier().size(); i++) {
5134      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
5135    }
5136    if (element.hasStatusElement()) {
5137      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
5138    }
5139    if (element.hasType()) {
5140      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
5141    }
5142    if (element.hasSubType()) {
5143      composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1);
5144    }
5145    if (element.hasUseElement()) {
5146      composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1);
5147    }
5148    if (element.hasPatient()) {
5149      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
5150    }
5151    if (element.hasCreatedElement()) {
5152      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
5153    }
5154    if (element.hasInsurer()) {
5155      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
5156    }
5157    if (element.hasRequestor()) {
5158      composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1);
5159    }
5160    if (element.hasRequest()) {
5161      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
5162    }
5163    if (element.hasOutcomeElement()) {
5164      composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1);
5165    }
5166    if (element.hasDispositionElement()) {
5167      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
5168    }
5169    if (element.hasPreAuthRefElement()) {
5170      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
5171    }
5172    if (element.hasPreAuthPeriod()) {
5173      composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1);
5174    }
5175    if (element.hasPayeeType()) {
5176      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
5177    }
5178    for (int i = 0; i < element.getItem().size(); i++) {
5179      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
5180    }
5181    for (int i = 0; i < element.getAddItem().size(); i++) {
5182      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
5183    }
5184    for (int i = 0; i < element.getAdjudication().size(); i++) {
5185      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
5186    }
5187    for (int i = 0; i < element.getTotal().size(); i++) {
5188      composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i);
5189    }
5190    if (element.hasPayment()) {
5191      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
5192    }
5193    if (element.hasFundsReserve()) {
5194      composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1);
5195    }
5196    if (element.hasFormCode()) {
5197      composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1);
5198    }
5199    if (element.hasForm()) {
5200      composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1);
5201    }
5202    for (int i = 0; i < element.getProcessNote().size(); i++) {
5203      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
5204    }
5205    for (int i = 0; i < element.getCommunicationRequest().size(); i++) {
5206      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
5207    }
5208    for (int i = 0; i < element.getInsurance().size(); i++) {
5209      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
5210    }
5211    for (int i = 0; i < element.getError().size(); i++) {
5212      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
5213    }
5214  }
5215
5216  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
5217    if (element == null) 
5218      return;
5219    Complex t;
5220    if (Utilities.noString(parentType))
5221      t = parent;
5222    else {
5223      t = parent.predicate("fhir:"+parentType+'.'+name);
5224    }
5225    composeBackboneElement(t, "item", name, element, index);
5226    if (element.hasItemSequenceElement()) {
5227      composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1);
5228    }
5229    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5230      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
5231    }
5232    for (int i = 0; i < element.getAdjudication().size(); i++) {
5233      composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
5234    }
5235    for (int i = 0; i < element.getDetail().size(); i++) {
5236      composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
5237    }
5238  }
5239
5240  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
5241    if (element == null) 
5242      return;
5243    Complex t;
5244    if (Utilities.noString(parentType))
5245      t = parent;
5246    else {
5247      t = parent.predicate("fhir:"+parentType+'.'+name);
5248    }
5249    composeBackboneElement(t, "adjudication", name, element, index);
5250    if (element.hasCategory()) {
5251      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
5252    }
5253    if (element.hasReason()) {
5254      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
5255    }
5256    if (element.hasAmount()) {
5257      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
5258    }
5259    if (element.hasValueElement()) {
5260      composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1);
5261    }
5262  }
5263
5264  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) {
5265    if (element == null) 
5266      return;
5267    Complex t;
5268    if (Utilities.noString(parentType))
5269      t = parent;
5270    else {
5271      t = parent.predicate("fhir:"+parentType+'.'+name);
5272    }
5273    composeBackboneElement(t, "detail", name, element, index);
5274    if (element.hasDetailSequenceElement()) {
5275      composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1);
5276    }
5277    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5278      composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5279    }
5280    for (int i = 0; i < element.getAdjudication().size(); i++) {
5281      composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5282    }
5283    for (int i = 0; i < element.getSubDetail().size(); i++) {
5284      composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
5285    }
5286  }
5287
5288  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
5289    if (element == null) 
5290      return;
5291    Complex t;
5292    if (Utilities.noString(parentType))
5293      t = parent;
5294    else {
5295      t = parent.predicate("fhir:"+parentType+'.'+name);
5296    }
5297    composeBackboneElement(t, "subDetail", name, element, index);
5298    if (element.hasSubDetailSequenceElement()) {
5299      composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
5300    }
5301    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5302      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5303    }
5304    for (int i = 0; i < element.getAdjudication().size(); i++) {
5305      composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5306    }
5307  }
5308
5309  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
5310    if (element == null) 
5311      return;
5312    Complex t;
5313    if (Utilities.noString(parentType))
5314      t = parent;
5315    else {
5316      t = parent.predicate("fhir:"+parentType+'.'+name);
5317    }
5318    composeBackboneElement(t, "addItem", name, element, index);
5319    for (int i = 0; i < element.getItemSequence().size(); i++) {
5320      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
5321    }
5322    for (int i = 0; i < element.getDetailSequence().size(); i++) {
5323      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
5324    }
5325    for (int i = 0; i < element.getSubdetailSequence().size(); i++) {
5326      composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i);
5327    }
5328    for (int i = 0; i < element.getProvider().size(); i++) {
5329      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
5330    }
5331    if (element.hasProductOrService()) {
5332      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
5333    }
5334    for (int i = 0; i < element.getModifier().size(); i++) {
5335      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
5336    }
5337    for (int i = 0; i < element.getProgramCode().size(); i++) {
5338      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
5339    }
5340    if (element.hasServiced()) {
5341      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
5342    }
5343    if (element.hasLocation()) {
5344      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
5345    }
5346    if (element.hasQuantity()) {
5347      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
5348    }
5349    if (element.hasUnitPrice()) {
5350      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
5351    }
5352    if (element.hasFactorElement()) {
5353      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
5354    }
5355    if (element.hasNet()) {
5356      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
5357    }
5358    if (element.hasBodySite()) {
5359      composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1);
5360    }
5361    for (int i = 0; i < element.getSubSite().size(); i++) {
5362      composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i);
5363    }
5364    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5365      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
5366    }
5367    for (int i = 0; i < element.getAdjudication().size(); i++) {
5368      composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
5369    }
5370    for (int i = 0; i < element.getDetail().size(); i++) {
5371      composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
5372    }
5373  }
5374
5375  protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) {
5376    if (element == null) 
5377      return;
5378    Complex t;
5379    if (Utilities.noString(parentType))
5380      t = parent;
5381    else {
5382      t = parent.predicate("fhir:"+parentType+'.'+name);
5383    }
5384    composeBackboneElement(t, "detail", name, element, index);
5385    if (element.hasProductOrService()) {
5386      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
5387    }
5388    for (int i = 0; i < element.getModifier().size(); i++) {
5389      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
5390    }
5391    if (element.hasQuantity()) {
5392      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
5393    }
5394    if (element.hasUnitPrice()) {
5395      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5396    }
5397    if (element.hasFactorElement()) {
5398      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
5399    }
5400    if (element.hasNet()) {
5401      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
5402    }
5403    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5404      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5405    }
5406    for (int i = 0; i < element.getAdjudication().size(); i++) {
5407      composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5408    }
5409    for (int i = 0; i < element.getSubDetail().size(); i++) {
5410      composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
5411    }
5412  }
5413
5414  protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) {
5415    if (element == null) 
5416      return;
5417    Complex t;
5418    if (Utilities.noString(parentType))
5419      t = parent;
5420    else {
5421      t = parent.predicate("fhir:"+parentType+'.'+name);
5422    }
5423    composeBackboneElement(t, "subDetail", name, element, index);
5424    if (element.hasProductOrService()) {
5425      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1);
5426    }
5427    for (int i = 0; i < element.getModifier().size(); i++) {
5428      composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i);
5429    }
5430    if (element.hasQuantity()) {
5431      composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1);
5432    }
5433    if (element.hasUnitPrice()) {
5434      composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5435    }
5436    if (element.hasFactorElement()) {
5437      composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1);
5438    }
5439    if (element.hasNet()) {
5440      composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1);
5441    }
5442    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5443      composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5444    }
5445    for (int i = 0; i < element.getAdjudication().size(); i++) {
5446      composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5447    }
5448  }
5449
5450  protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) {
5451    if (element == null) 
5452      return;
5453    Complex t;
5454    if (Utilities.noString(parentType))
5455      t = parent;
5456    else {
5457      t = parent.predicate("fhir:"+parentType+'.'+name);
5458    }
5459    composeBackboneElement(t, "total", name, element, index);
5460    if (element.hasCategory()) {
5461      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
5462    }
5463    if (element.hasAmount()) {
5464      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
5465    }
5466  }
5467
5468  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) {
5469    if (element == null) 
5470      return;
5471    Complex t;
5472    if (Utilities.noString(parentType))
5473      t = parent;
5474    else {
5475      t = parent.predicate("fhir:"+parentType+'.'+name);
5476    }
5477    composeBackboneElement(t, "payment", name, element, index);
5478    if (element.hasType()) {
5479      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
5480    }
5481    if (element.hasAdjustment()) {
5482      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
5483    }
5484    if (element.hasAdjustmentReason()) {
5485      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
5486    }
5487    if (element.hasDateElement()) {
5488      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
5489    }
5490    if (element.hasAmount()) {
5491      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
5492    }
5493    if (element.hasIdentifier()) {
5494      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
5495    }
5496  }
5497
5498  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
5499    if (element == null) 
5500      return;
5501    Complex t;
5502    if (Utilities.noString(parentType))
5503      t = parent;
5504    else {
5505      t = parent.predicate("fhir:"+parentType+'.'+name);
5506    }
5507    composeBackboneElement(t, "processNote", name, element, index);
5508    if (element.hasNumberElement()) {
5509      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
5510    }
5511    if (element.hasTypeElement()) {
5512      composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1);
5513    }
5514    if (element.hasTextElement()) {
5515      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
5516    }
5517    if (element.hasLanguage()) {
5518      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
5519    }
5520  }
5521
5522  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
5523    if (element == null) 
5524      return;
5525    Complex t;
5526    if (Utilities.noString(parentType))
5527      t = parent;
5528    else {
5529      t = parent.predicate("fhir:"+parentType+'.'+name);
5530    }
5531    composeBackboneElement(t, "insurance", name, element, index);
5532    if (element.hasSequenceElement()) {
5533      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
5534    }
5535    if (element.hasFocalElement()) {
5536      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
5537    }
5538    if (element.hasCoverage()) {
5539      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
5540    }
5541    if (element.hasBusinessArrangementElement()) {
5542      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
5543    }
5544    if (element.hasClaimResponse()) {
5545      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
5546    }
5547  }
5548
5549  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
5550    if (element == null) 
5551      return;
5552    Complex t;
5553    if (Utilities.noString(parentType))
5554      t = parent;
5555    else {
5556      t = parent.predicate("fhir:"+parentType+'.'+name);
5557    }
5558    composeBackboneElement(t, "error", name, element, index);
5559    if (element.hasItemSequenceElement()) {
5560      composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1);
5561    }
5562    if (element.hasDetailSequenceElement()) {
5563      composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1);
5564    }
5565    if (element.hasSubDetailSequenceElement()) {
5566      composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
5567    }
5568    if (element.hasCode()) {
5569      composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1);
5570    }
5571  }
5572
5573  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) {
5574    if (element == null) 
5575      return;
5576    Complex t;
5577    if (Utilities.noString(parentType))
5578      t = parent;
5579    else {
5580      t = parent.predicate("fhir:"+parentType+'.'+name);
5581    }
5582    composeDomainResource(t, "ClinicalImpression", name, element, index);
5583    for (int i = 0; i < element.getIdentifier().size(); i++) {
5584      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
5585    }
5586    if (element.hasStatusElement()) {
5587      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
5588    }
5589    if (element.hasStatusReason()) {
5590      composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1);
5591    }
5592    if (element.hasCode()) {
5593      composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1);
5594    }
5595    if (element.hasDescriptionElement()) {
5596      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
5597    }
5598    if (element.hasSubject()) {
5599      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
5600    }
5601    if (element.hasEncounter()) {
5602      composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1);
5603    }
5604    if (element.hasEffective()) {
5605      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
5606    }
5607    if (element.hasDateElement()) {
5608      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
5609    }
5610    if (element.hasAssessor()) {
5611      composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1);
5612    }
5613    if (element.hasPrevious()) {
5614      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
5615    }
5616    for (int i = 0; i < element.getProblem().size(); i++) {
5617      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
5618    }
5619    for (int i = 0; i < element.getInvestigation().size(); i++) {
5620      composeClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i);
5621    }
5622    for (int i = 0; i < element.getProtocol().size(); i++) {
5623      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
5624    }
5625    if (element.hasSummaryElement()) {
5626      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
5627    }
5628    for (int i = 0; i < element.getFinding().size(); i++) {
5629      composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
5630    }
5631    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) {
5632      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
5633    }
5634    for (int i = 0; i < element.getPrognosisReference().size(); i++) {
5635      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
5636    }
5637    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
5638      composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i);
5639    }
5640    for (int i = 0; i < element.getNote().size(); i++) {
5641      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
5642    }
5643  }
5644
5645  protected void composeClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) {
5646    if (element == null) 
5647      return;
5648    Complex t;
5649    if (Utilities.noString(parentType))
5650      t = parent;
5651    else {
5652      t = parent.predicate("fhir:"+parentType+'.'+name);
5653    }
5654    composeBackboneElement(t, "investigation", name, element, index);
5655    if (element.hasCode()) {
5656      composeCodeableConcept(t, "ClinicalImpressionInvestigationComponent", "code", element.getCode(), -1);
5657    }
5658    for (int i = 0; i < element.getItem().size(); i++) {
5659      composeReference(t, "ClinicalImpressionInvestigationComponent", "item", element.getItem().get(i), i);
5660    }
5661  }
5662
5663  protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
5664    if (element == null) 
5665      return;
5666    Complex t;
5667    if (Utilities.noString(parentType))
5668      t = parent;
5669    else {
5670      t = parent.predicate("fhir:"+parentType+'.'+name);
5671    }
5672    composeBackboneElement(t, "finding", name, element, index);
5673    if (element.hasItemCodeableConcept()) {
5674      composeCodeableConcept(t, "ClinicalImpressionFindingComponent", "itemCodeableConcept", element.getItemCodeableConcept(), -1);
5675    }
5676    if (element.hasItemReference()) {
5677      composeReference(t, "ClinicalImpressionFindingComponent", "itemReference", element.getItemReference(), -1);
5678    }
5679    if (element.hasBasisElement()) {
5680      composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1);
5681    }
5682  }
5683
5684  protected void composeClinicalUseDefinition(Complex parent, String parentType, String name, ClinicalUseDefinition element, int index) {
5685    if (element == null) 
5686      return;
5687    Complex t;
5688    if (Utilities.noString(parentType))
5689      t = parent;
5690    else {
5691      t = parent.predicate("fhir:"+parentType+'.'+name);
5692    }
5693    composeDomainResource(t, "ClinicalUseDefinition", name, element, index);
5694    for (int i = 0; i < element.getIdentifier().size(); i++) {
5695      composeIdentifier(t, "ClinicalUseDefinition", "identifier", element.getIdentifier().get(i), i);
5696    }
5697    if (element.hasTypeElement()) {
5698      composeEnum(t, "ClinicalUseDefinition", "type", element.getTypeElement(), -1);
5699    }
5700    for (int i = 0; i < element.getCategory().size(); i++) {
5701      composeCodeableConcept(t, "ClinicalUseDefinition", "category", element.getCategory().get(i), i);
5702    }
5703    for (int i = 0; i < element.getSubject().size(); i++) {
5704      composeReference(t, "ClinicalUseDefinition", "subject", element.getSubject().get(i), i);
5705    }
5706    if (element.hasStatus()) {
5707      composeCodeableConcept(t, "ClinicalUseDefinition", "status", element.getStatus(), -1);
5708    }
5709    if (element.hasContraindication()) {
5710      composeClinicalUseDefinitionContraindicationComponent(t, "ClinicalUseDefinition", "contraindication", element.getContraindication(), -1);
5711    }
5712    if (element.hasIndication()) {
5713      composeClinicalUseDefinitionIndicationComponent(t, "ClinicalUseDefinition", "indication", element.getIndication(), -1);
5714    }
5715    if (element.hasInteraction()) {
5716      composeClinicalUseDefinitionInteractionComponent(t, "ClinicalUseDefinition", "interaction", element.getInteraction(), -1);
5717    }
5718    for (int i = 0; i < element.getPopulation().size(); i++) {
5719      composeReference(t, "ClinicalUseDefinition", "population", element.getPopulation().get(i), i);
5720    }
5721    if (element.hasUndesirableEffect()) {
5722      composeClinicalUseDefinitionUndesirableEffectComponent(t, "ClinicalUseDefinition", "undesirableEffect", element.getUndesirableEffect(), -1);
5723    }
5724    if (element.hasWarning()) {
5725      composeClinicalUseDefinitionWarningComponent(t, "ClinicalUseDefinition", "warning", element.getWarning(), -1);
5726    }
5727  }
5728
5729  protected void composeClinicalUseDefinitionContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent element, int index) {
5730    if (element == null) 
5731      return;
5732    Complex t;
5733    if (Utilities.noString(parentType))
5734      t = parent;
5735    else {
5736      t = parent.predicate("fhir:"+parentType+'.'+name);
5737    }
5738    composeBackboneElement(t, "contraindication", name, element, index);
5739    if (element.hasDiseaseSymptomProcedure()) {
5740      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
5741    }
5742    if (element.hasDiseaseStatus()) {
5743      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
5744    }
5745    for (int i = 0; i < element.getComorbidity().size(); i++) {
5746      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i);
5747    }
5748    for (int i = 0; i < element.getIndication().size(); i++) {
5749      composeReference(t, "ClinicalUseDefinitionContraindicationComponent", "indication", element.getIndication().get(i), i);
5750    }
5751    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
5752      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
5753    }
5754  }
5755
5756  protected void composeClinicalUseDefinitionContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent element, int index) {
5757    if (element == null) 
5758      return;
5759    Complex t;
5760    if (Utilities.noString(parentType))
5761      t = parent;
5762    else {
5763      t = parent.predicate("fhir:"+parentType+'.'+name);
5764    }
5765    composeBackboneElement(t, "otherTherapy", name, element, index);
5766    if (element.hasRelationshipType()) {
5767      composeCodeableConcept(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "relationshipType", element.getRelationshipType(), -1);
5768    }
5769    if (element.hasTherapy()) {
5770      composeCodeableReference(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "therapy", element.getTherapy(), -1);
5771    }
5772  }
5773
5774  protected void composeClinicalUseDefinitionIndicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent element, int index) {
5775    if (element == null) 
5776      return;
5777    Complex t;
5778    if (Utilities.noString(parentType))
5779      t = parent;
5780    else {
5781      t = parent.predicate("fhir:"+parentType+'.'+name);
5782    }
5783    composeBackboneElement(t, "indication", name, element, index);
5784    if (element.hasDiseaseSymptomProcedure()) {
5785      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
5786    }
5787    if (element.hasDiseaseStatus()) {
5788      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
5789    }
5790    for (int i = 0; i < element.getComorbidity().size(); i++) {
5791      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "comorbidity", element.getComorbidity().get(i), i);
5792    }
5793    if (element.hasIntendedEffect()) {
5794      composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1);
5795    }
5796    if (element.hasDuration()) {
5797      composeQuantity(t, "ClinicalUseDefinitionIndicationComponent", "duration", element.getDuration(), -1);
5798    }
5799    for (int i = 0; i < element.getUndesirableEffect().size(); i++) {
5800      composeReference(t, "ClinicalUseDefinitionIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i);
5801    }
5802    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
5803      composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
5804    }
5805  }
5806
5807  protected void composeClinicalUseDefinitionInteractionComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent element, int index) {
5808    if (element == null) 
5809      return;
5810    Complex t;
5811    if (Utilities.noString(parentType))
5812      t = parent;
5813    else {
5814      t = parent.predicate("fhir:"+parentType+'.'+name);
5815    }
5816    composeBackboneElement(t, "interaction", name, element, index);
5817    for (int i = 0; i < element.getInteractant().size(); i++) {
5818      composeClinicalUseDefinitionInteractionInteractantComponent(t, "ClinicalUseDefinitionInteractionComponent", "interactant", element.getInteractant().get(i), i);
5819    }
5820    if (element.hasType()) {
5821      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "type", element.getType(), -1);
5822    }
5823    if (element.hasEffect()) {
5824      composeCodeableReference(t, "ClinicalUseDefinitionInteractionComponent", "effect", element.getEffect(), -1);
5825    }
5826    if (element.hasIncidence()) {
5827      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "incidence", element.getIncidence(), -1);
5828    }
5829    for (int i = 0; i < element.getManagement().size(); i++) {
5830      composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "management", element.getManagement().get(i), i);
5831    }
5832  }
5833
5834  protected void composeClinicalUseDefinitionInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent element, int index) {
5835    if (element == null) 
5836      return;
5837    Complex t;
5838    if (Utilities.noString(parentType))
5839      t = parent;
5840    else {
5841      t = parent.predicate("fhir:"+parentType+'.'+name);
5842    }
5843    composeBackboneElement(t, "interactant", name, element, index);
5844    if (element.hasItem()) {
5845      composeType(t, "ClinicalUseDefinitionInteractionInteractantComponent", "item", element.getItem(), -1);
5846    }
5847  }
5848
5849  protected void composeClinicalUseDefinitionUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent element, int index) {
5850    if (element == null) 
5851      return;
5852    Complex t;
5853    if (Utilities.noString(parentType))
5854      t = parent;
5855    else {
5856      t = parent.predicate("fhir:"+parentType+'.'+name);
5857    }
5858    composeBackboneElement(t, "undesirableEffect", name, element, index);
5859    if (element.hasSymptomConditionEffect()) {
5860      composeCodeableReference(t, "ClinicalUseDefinitionUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1);
5861    }
5862    if (element.hasClassification()) {
5863      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "classification", element.getClassification(), -1);
5864    }
5865    if (element.hasFrequencyOfOccurrence()) {
5866      composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1);
5867    }
5868  }
5869
5870  protected void composeClinicalUseDefinitionWarningComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent element, int index) {
5871    if (element == null) 
5872      return;
5873    Complex t;
5874    if (Utilities.noString(parentType))
5875      t = parent;
5876    else {
5877      t = parent.predicate("fhir:"+parentType+'.'+name);
5878    }
5879    composeBackboneElement(t, "warning", name, element, index);
5880    if (element.hasDescriptionElement()) {
5881      composeMarkdown(t, "ClinicalUseDefinitionWarningComponent", "description", element.getDescriptionElement(), -1);
5882    }
5883    if (element.hasCode()) {
5884      composeCodeableConcept(t, "ClinicalUseDefinitionWarningComponent", "code", element.getCode(), -1);
5885    }
5886  }
5887
5888  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) {
5889    if (element == null) 
5890      return;
5891    Complex t;
5892    if (Utilities.noString(parentType))
5893      t = parent;
5894    else {
5895      t = parent.predicate("fhir:"+parentType+'.'+name);
5896    }
5897    composeDomainResource(t, "CodeSystem", name, element, index);
5898    if (element.hasUrlElement()) {
5899      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
5900    }
5901    for (int i = 0; i < element.getIdentifier().size(); i++) {
5902      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i);
5903    }
5904    if (element.hasVersionElement()) {
5905      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
5906    }
5907    if (element.hasNameElement()) {
5908      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
5909    }
5910    if (element.hasTitleElement()) {
5911      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
5912    }
5913    if (element.hasStatusElement()) {
5914      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
5915    }
5916    if (element.hasExperimentalElement()) {
5917      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
5918    }
5919    if (element.hasDateElement()) {
5920      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
5921    }
5922    if (element.hasPublisherElement()) {
5923      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
5924    }
5925    for (int i = 0; i < element.getContact().size(); i++) {
5926      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
5927    }
5928    if (element.hasDescriptionElement()) {
5929      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
5930    }
5931    for (int i = 0; i < element.getUseContext().size(); i++) {
5932      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
5933    }
5934    for (int i = 0; i < element.getJurisdiction().size(); i++) {
5935      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
5936    }
5937    if (element.hasPurposeElement()) {
5938      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
5939    }
5940    if (element.hasCopyrightElement()) {
5941      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
5942    }
5943    if (element.hasCaseSensitiveElement()) {
5944      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
5945    }
5946    if (element.hasValueSetElement()) {
5947      composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
5948    }
5949    if (element.hasHierarchyMeaningElement()) {
5950      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
5951    }
5952    if (element.hasCompositionalElement()) {
5953      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
5954    }
5955    if (element.hasVersionNeededElement()) {
5956      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
5957    }
5958    if (element.hasContentElement()) {
5959      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
5960    }
5961    if (element.hasSupplementsElement()) {
5962      composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1);
5963    }
5964    if (element.hasCountElement()) {
5965      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
5966    }
5967    for (int i = 0; i < element.getFilter().size(); i++) {
5968      composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
5969    }
5970    for (int i = 0; i < element.getProperty().size(); i++) {
5971      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
5972    }
5973    for (int i = 0; i < element.getConcept().size(); i++) {
5974      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
5975    }
5976  }
5977
5978  protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) {
5979    if (element == null) 
5980      return;
5981    Complex t;
5982    if (Utilities.noString(parentType))
5983      t = parent;
5984    else {
5985      t = parent.predicate("fhir:"+parentType+'.'+name);
5986    }
5987    composeBackboneElement(t, "filter", name, element, index);
5988    if (element.hasCodeElement()) {
5989      composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1);
5990    }
5991    if (element.hasDescriptionElement()) {
5992      composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1);
5993    }
5994    for (int i = 0; i < element.getOperator().size(); i++) {
5995      composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i);
5996    }
5997    if (element.hasValueElement()) {
5998      composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1);
5999    }
6000  }
6001
6002  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
6003    if (element == null) 
6004      return;
6005    Complex t;
6006    if (Utilities.noString(parentType))
6007      t = parent;
6008    else {
6009      t = parent.predicate("fhir:"+parentType+'.'+name);
6010    }
6011    composeBackboneElement(t, "property", name, element, index);
6012    if (element.hasCodeElement()) {
6013      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
6014    }
6015    if (element.hasUriElement()) {
6016      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
6017    }
6018    if (element.hasDescriptionElement()) {
6019      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
6020    }
6021    if (element.hasTypeElement()) {
6022      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
6023    }
6024  }
6025
6026  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
6027    if (element == null) 
6028      return;
6029    Complex t;
6030    if (Utilities.noString(parentType))
6031      t = parent;
6032    else {
6033      t = parent.predicate("fhir:"+parentType+'.'+name);
6034    }
6035    composeBackboneElement(t, "concept", name, element, index);
6036    if (element.hasCodeElement()) {
6037      composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1);
6038    }
6039    if (element.hasDisplayElement()) {
6040      composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1);
6041    }
6042    if (element.hasDefinitionElement()) {
6043      composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1);
6044    }
6045    for (int i = 0; i < element.getDesignation().size(); i++) {
6046      composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i);
6047    }
6048    for (int i = 0; i < element.getProperty().size(); i++) {
6049      composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i);
6050    }
6051    for (int i = 0; i < element.getConcept().size(); i++) {
6052      composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i);
6053    }
6054  }
6055
6056  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
6057    if (element == null) 
6058      return;
6059    Complex t;
6060    if (Utilities.noString(parentType))
6061      t = parent;
6062    else {
6063      t = parent.predicate("fhir:"+parentType+'.'+name);
6064    }
6065    composeBackboneElement(t, "designation", name, element, index);
6066    if (element.hasLanguageElement()) {
6067      composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1);
6068    }
6069    if (element.hasUse()) {
6070      composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1);
6071    }
6072    if (element.hasValueElement()) {
6073      composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1);
6074    }
6075  }
6076
6077  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
6078    if (element == null) 
6079      return;
6080    Complex t;
6081    if (Utilities.noString(parentType))
6082      t = parent;
6083    else {
6084      t = parent.predicate("fhir:"+parentType+'.'+name);
6085    }
6086    composeBackboneElement(t, "property", name, element, index);
6087    if (element.hasCodeElement()) {
6088      composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1);
6089    }
6090    if (element.hasValue()) {
6091      composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1);
6092    }
6093  }
6094
6095  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
6096    if (element == null) 
6097      return;
6098    Complex t;
6099    if (Utilities.noString(parentType))
6100      t = parent;
6101    else {
6102      t = parent.predicate("fhir:"+parentType+'.'+name);
6103    }
6104    composeDomainResource(t, "Communication", name, element, index);
6105    for (int i = 0; i < element.getIdentifier().size(); i++) {
6106      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
6107    }
6108    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
6109      composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
6110    }
6111    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
6112      composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i);
6113    }
6114    for (int i = 0; i < element.getBasedOn().size(); i++) {
6115      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
6116    }
6117    for (int i = 0; i < element.getPartOf().size(); i++) {
6118      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
6119    }
6120    for (int i = 0; i < element.getInResponseTo().size(); i++) {
6121      composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i);
6122    }
6123    if (element.hasStatusElement()) {
6124      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
6125    }
6126    if (element.hasStatusReason()) {
6127      composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1);
6128    }
6129    for (int i = 0; i < element.getCategory().size(); i++) {
6130      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
6131    }
6132    if (element.hasPriorityElement()) {
6133      composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1);
6134    }
6135    for (int i = 0; i < element.getMedium().size(); i++) {
6136      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
6137    }
6138    if (element.hasSubject()) {
6139      composeReference(t, "Communication", "subject", element.getSubject(), -1);
6140    }
6141    if (element.hasTopic()) {
6142      composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1);
6143    }
6144    for (int i = 0; i < element.getAbout().size(); i++) {
6145      composeReference(t, "Communication", "about", element.getAbout().get(i), i);
6146    }
6147    if (element.hasEncounter()) {
6148      composeReference(t, "Communication", "encounter", element.getEncounter(), -1);
6149    }
6150    if (element.hasSentElement()) {
6151      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
6152    }
6153    if (element.hasReceivedElement()) {
6154      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
6155    }
6156    for (int i = 0; i < element.getRecipient().size(); i++) {
6157      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
6158    }
6159    if (element.hasSender()) {
6160      composeReference(t, "Communication", "sender", element.getSender(), -1);
6161    }
6162    for (int i = 0; i < element.getReasonCode().size(); i++) {
6163      composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i);
6164    }
6165    for (int i = 0; i < element.getReasonReference().size(); i++) {
6166      composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i);
6167    }
6168    for (int i = 0; i < element.getPayload().size(); i++) {
6169      composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
6170    }
6171    for (int i = 0; i < element.getNote().size(); i++) {
6172      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
6173    }
6174  }
6175
6176  protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
6177    if (element == null) 
6178      return;
6179    Complex t;
6180    if (Utilities.noString(parentType))
6181      t = parent;
6182    else {
6183      t = parent.predicate("fhir:"+parentType+'.'+name);
6184    }
6185    composeBackboneElement(t, "payload", name, element, index);
6186    if (element.hasContent()) {
6187      composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1);
6188    }
6189  }
6190
6191  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
6192    if (element == null) 
6193      return;
6194    Complex t;
6195    if (Utilities.noString(parentType))
6196      t = parent;
6197    else {
6198      t = parent.predicate("fhir:"+parentType+'.'+name);
6199    }
6200    composeDomainResource(t, "CommunicationRequest", name, element, index);
6201    for (int i = 0; i < element.getIdentifier().size(); i++) {
6202      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
6203    }
6204    for (int i = 0; i < element.getBasedOn().size(); i++) {
6205      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
6206    }
6207    for (int i = 0; i < element.getReplaces().size(); i++) {
6208      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
6209    }
6210    if (element.hasGroupIdentifier()) {
6211      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
6212    }
6213    if (element.hasStatusElement()) {
6214      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
6215    }
6216    if (element.hasStatusReason()) {
6217      composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1);
6218    }
6219    for (int i = 0; i < element.getCategory().size(); i++) {
6220      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
6221    }
6222    if (element.hasPriorityElement()) {
6223      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
6224    }
6225    if (element.hasDoNotPerformElement()) {
6226      composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
6227    }
6228    for (int i = 0; i < element.getMedium().size(); i++) {
6229      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
6230    }
6231    if (element.hasSubject()) {
6232      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
6233    }
6234    for (int i = 0; i < element.getAbout().size(); i++) {
6235      composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i);
6236    }
6237    if (element.hasEncounter()) {
6238      composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1);
6239    }
6240    for (int i = 0; i < element.getPayload().size(); i++) {
6241      composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
6242    }
6243    if (element.hasOccurrence()) {
6244      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
6245    }
6246    if (element.hasAuthoredOnElement()) {
6247      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
6248    }
6249    if (element.hasRequester()) {
6250      composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1);
6251    }
6252    for (int i = 0; i < element.getRecipient().size(); i++) {
6253      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
6254    }
6255    if (element.hasSender()) {
6256      composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1);
6257    }
6258    for (int i = 0; i < element.getReasonCode().size(); i++) {
6259      composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i);
6260    }
6261    for (int i = 0; i < element.getReasonReference().size(); i++) {
6262      composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i);
6263    }
6264    for (int i = 0; i < element.getNote().size(); i++) {
6265      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
6266    }
6267  }
6268
6269  protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
6270    if (element == null) 
6271      return;
6272    Complex t;
6273    if (Utilities.noString(parentType))
6274      t = parent;
6275    else {
6276      t = parent.predicate("fhir:"+parentType+'.'+name);
6277    }
6278    composeBackboneElement(t, "payload", name, element, index);
6279    if (element.hasContent()) {
6280      composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1);
6281    }
6282  }
6283
6284  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
6285    if (element == null) 
6286      return;
6287    Complex t;
6288    if (Utilities.noString(parentType))
6289      t = parent;
6290    else {
6291      t = parent.predicate("fhir:"+parentType+'.'+name);
6292    }
6293    composeDomainResource(t, "CompartmentDefinition", name, element, index);
6294    if (element.hasUrlElement()) {
6295      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
6296    }
6297    if (element.hasVersionElement()) {
6298      composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1);
6299    }
6300    if (element.hasNameElement()) {
6301      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
6302    }
6303    if (element.hasStatusElement()) {
6304      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
6305    }
6306    if (element.hasExperimentalElement()) {
6307      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
6308    }
6309    if (element.hasDateElement()) {
6310      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
6311    }
6312    if (element.hasPublisherElement()) {
6313      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
6314    }
6315    for (int i = 0; i < element.getContact().size(); i++) {
6316      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
6317    }
6318    if (element.hasDescriptionElement()) {
6319      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
6320    }
6321    for (int i = 0; i < element.getUseContext().size(); i++) {
6322      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
6323    }
6324    if (element.hasPurposeElement()) {
6325      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
6326    }
6327    if (element.hasCodeElement()) {
6328      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
6329    }
6330    if (element.hasSearchElement()) {
6331      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
6332    }
6333    for (int i = 0; i < element.getResource().size(); i++) {
6334      composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
6335    }
6336  }
6337
6338  protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
6339    if (element == null) 
6340      return;
6341    Complex t;
6342    if (Utilities.noString(parentType))
6343      t = parent;
6344    else {
6345      t = parent.predicate("fhir:"+parentType+'.'+name);
6346    }
6347    composeBackboneElement(t, "resource", name, element, index);
6348    if (element.hasCodeElement()) {
6349      composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1);
6350    }
6351    for (int i = 0; i < element.getParam().size(); i++) {
6352      composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i);
6353    }
6354    if (element.hasDocumentationElement()) {
6355      composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1);
6356    }
6357  }
6358
6359  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
6360    if (element == null) 
6361      return;
6362    Complex t;
6363    if (Utilities.noString(parentType))
6364      t = parent;
6365    else {
6366      t = parent.predicate("fhir:"+parentType+'.'+name);
6367    }
6368    composeDomainResource(t, "Composition", name, element, index);
6369    if (element.hasIdentifier()) {
6370      composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1);
6371    }
6372    if (element.hasStatusElement()) {
6373      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
6374    }
6375    if (element.hasType()) {
6376      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
6377    }
6378    for (int i = 0; i < element.getCategory().size(); i++) {
6379      composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i);
6380    }
6381    if (element.hasSubject()) {
6382      composeReference(t, "Composition", "subject", element.getSubject(), -1);
6383    }
6384    if (element.hasEncounter()) {
6385      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
6386    }
6387    if (element.hasDateElement()) {
6388      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
6389    }
6390    for (int i = 0; i < element.getAuthor().size(); i++) {
6391      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
6392    }
6393    if (element.hasTitleElement()) {
6394      composeString(t, "Composition", "title", element.getTitleElement(), -1);
6395    }
6396    if (element.hasConfidentialityElement()) {
6397      composeCode(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1);
6398    }
6399    for (int i = 0; i < element.getAttester().size(); i++) {
6400      composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
6401    }
6402    if (element.hasCustodian()) {
6403      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
6404    }
6405    for (int i = 0; i < element.getRelatesTo().size(); i++) {
6406      composeCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
6407    }
6408    for (int i = 0; i < element.getEvent().size(); i++) {
6409      composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
6410    }
6411    for (int i = 0; i < element.getSection().size(); i++) {
6412      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
6413    }
6414  }
6415
6416  protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
6417    if (element == null) 
6418      return;
6419    Complex t;
6420    if (Utilities.noString(parentType))
6421      t = parent;
6422    else {
6423      t = parent.predicate("fhir:"+parentType+'.'+name);
6424    }
6425    composeBackboneElement(t, "attester", name, element, index);
6426    if (element.hasModeElement()) {
6427      composeEnum(t, "CompositionAttesterComponent", "mode", element.getModeElement(), -1);
6428    }
6429    if (element.hasTimeElement()) {
6430      composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1);
6431    }
6432    if (element.hasParty()) {
6433      composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1);
6434    }
6435  }
6436
6437  protected void composeCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) {
6438    if (element == null) 
6439      return;
6440    Complex t;
6441    if (Utilities.noString(parentType))
6442      t = parent;
6443    else {
6444      t = parent.predicate("fhir:"+parentType+'.'+name);
6445    }
6446    composeBackboneElement(t, "relatesTo", name, element, index);
6447    if (element.hasCodeElement()) {
6448      composeEnum(t, "CompositionRelatesToComponent", "code", element.getCodeElement(), -1);
6449    }
6450    if (element.hasTarget()) {
6451      composeType(t, "CompositionRelatesToComponent", "target", element.getTarget(), -1);
6452    }
6453  }
6454
6455  protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
6456    if (element == null) 
6457      return;
6458    Complex t;
6459    if (Utilities.noString(parentType))
6460      t = parent;
6461    else {
6462      t = parent.predicate("fhir:"+parentType+'.'+name);
6463    }
6464    composeBackboneElement(t, "event", name, element, index);
6465    for (int i = 0; i < element.getCode().size(); i++) {
6466      composeCodeableConcept(t, "CompositionEventComponent", "code", element.getCode().get(i), i);
6467    }
6468    if (element.hasPeriod()) {
6469      composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1);
6470    }
6471    for (int i = 0; i < element.getDetail().size(); i++) {
6472      composeReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i);
6473    }
6474  }
6475
6476  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
6477    if (element == null) 
6478      return;
6479    Complex t;
6480    if (Utilities.noString(parentType))
6481      t = parent;
6482    else {
6483      t = parent.predicate("fhir:"+parentType+'.'+name);
6484    }
6485    composeBackboneElement(t, "section", name, element, index);
6486    if (element.hasTitleElement()) {
6487      composeString(t, "SectionComponent", "title", element.getTitleElement(), -1);
6488    }
6489    if (element.hasCode()) {
6490      composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1);
6491    }
6492    for (int i = 0; i < element.getAuthor().size(); i++) {
6493      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
6494    }
6495    if (element.hasFocus()) {
6496      composeReference(t, "SectionComponent", "focus", element.getFocus(), -1);
6497    }
6498    if (element.hasText()) {
6499      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
6500    }
6501    if (element.hasModeElement()) {
6502      composeEnum(t, "SectionComponent", "mode", element.getModeElement(), -1);
6503    }
6504    if (element.hasOrderedBy()) {
6505      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
6506    }
6507    for (int i = 0; i < element.getEntry().size(); i++) {
6508      composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i);
6509    }
6510    if (element.hasEmptyReason()) {
6511      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
6512    }
6513    for (int i = 0; i < element.getSection().size(); i++) {
6514      composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
6515    }
6516  }
6517
6518  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
6519    if (element == null) 
6520      return;
6521    Complex t;
6522    if (Utilities.noString(parentType))
6523      t = parent;
6524    else {
6525      t = parent.predicate("fhir:"+parentType+'.'+name);
6526    }
6527    composeDomainResource(t, "ConceptMap", name, element, index);
6528    if (element.hasUrlElement()) {
6529      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
6530    }
6531    if (element.hasIdentifier()) {
6532      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifierFirstRep(), -1);
6533    }
6534    if (element.hasVersionElement()) {
6535      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
6536    }
6537    if (element.hasNameElement()) {
6538      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
6539    }
6540    if (element.hasTitleElement()) {
6541      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
6542    }
6543    if (element.hasStatusElement()) {
6544      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
6545    }
6546    if (element.hasExperimentalElement()) {
6547      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
6548    }
6549    if (element.hasDateElement()) {
6550      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
6551    }
6552    if (element.hasPublisherElement()) {
6553      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
6554    }
6555    for (int i = 0; i < element.getContact().size(); i++) {
6556      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
6557    }
6558    if (element.hasDescriptionElement()) {
6559      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
6560    }
6561    for (int i = 0; i < element.getUseContext().size(); i++) {
6562      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
6563    }
6564    for (int i = 0; i < element.getJurisdiction().size(); i++) {
6565      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
6566    }
6567    if (element.hasPurposeElement()) {
6568      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
6569    }
6570    if (element.hasCopyrightElement()) {
6571      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
6572    }
6573    if (element.hasSource()) {
6574      composeType(t, "ConceptMap", "source", element.getSource(), -1);
6575    }
6576    if (element.hasTarget()) {
6577      composeType(t, "ConceptMap", "target", element.getTarget(), -1);
6578    }
6579    for (int i = 0; i < element.getGroup().size(); i++) {
6580      composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
6581    }
6582  }
6583
6584  protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
6585    if (element == null) 
6586      return;
6587    Complex t;
6588    if (Utilities.noString(parentType))
6589      t = parent;
6590    else {
6591      t = parent.predicate("fhir:"+parentType+'.'+name);
6592    }
6593    composeBackboneElement(t, "group", name, element, index);
6594    if (element.hasSourceElement()) {
6595      composeUri(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1);
6596    }
6597    if (element.hasSourceVersionElement()) {
6598      composeString(t, "ConceptMapGroupComponent", "sourceVersion", element.getSourceVersionElement(), -1);
6599    }
6600    if (element.hasTargetElement()) {
6601      composeUri(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1);
6602    }
6603    if (element.hasTargetVersionElement()) {
6604      composeString(t, "ConceptMapGroupComponent", "targetVersion", element.getTargetVersionElement(), -1);
6605    }
6606    for (int i = 0; i < element.getElement().size(); i++) {
6607      composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i);
6608    }
6609    if (element.hasUnmapped()) {
6610      composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1);
6611    }
6612  }
6613
6614  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
6615    if (element == null) 
6616      return;
6617    Complex t;
6618    if (Utilities.noString(parentType))
6619      t = parent;
6620    else {
6621      t = parent.predicate("fhir:"+parentType+'.'+name);
6622    }
6623    composeBackboneElement(t, "element", name, element, index);
6624    if (element.hasCodeElement()) {
6625      composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1);
6626    }
6627    if (element.hasDisplayElement()) {
6628      composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1);
6629    }
6630    for (int i = 0; i < element.getTarget().size(); i++) {
6631      composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i);
6632    }
6633  }
6634
6635  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
6636    if (element == null) 
6637      return;
6638    Complex t;
6639    if (Utilities.noString(parentType))
6640      t = parent;
6641    else {
6642      t = parent.predicate("fhir:"+parentType+'.'+name);
6643    }
6644    composeBackboneElement(t, "target", name, element, index);
6645    if (element.hasCodeElement()) {
6646      composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1);
6647    }
6648    if (element.hasDisplayElement()) {
6649      composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1);
6650    }
6651    if (element.hasEquivalenceElement()) {
6652      composeEnum(t, "TargetElementComponent", "equivalence", element.getEquivalenceElement(), -1);
6653    }
6654    if (element.hasCommentElement()) {
6655      composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1);
6656    }
6657    for (int i = 0; i < element.getDependsOn().size(); i++) {
6658      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i);
6659    }
6660    for (int i = 0; i < element.getProduct().size(); i++) {
6661      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i);
6662    }
6663  }
6664
6665  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
6666    if (element == null) 
6667      return;
6668    Complex t;
6669    if (Utilities.noString(parentType))
6670      t = parent;
6671    else {
6672      t = parent.predicate("fhir:"+parentType+'.'+name);
6673    }
6674    composeBackboneElement(t, "dependsOn", name, element, index);
6675    if (element.hasPropertyElement()) {
6676      composeUri(t, "OtherElementComponent", "property", element.getPropertyElement(), -1);
6677    }
6678    if (element.hasSystemElement()) {
6679      composeCanonical(t, "OtherElementComponent", "system", element.getSystemElement(), -1);
6680    }
6681    if (element.hasValueElement()) {
6682      composeString(t, "OtherElementComponent", "value", element.getValueElement(), -1);
6683    }
6684    if (element.hasDisplayElement()) {
6685      composeString(t, "OtherElementComponent", "display", element.getDisplayElement(), -1);
6686    }
6687  }
6688
6689  protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
6690    if (element == null) 
6691      return;
6692    Complex t;
6693    if (Utilities.noString(parentType))
6694      t = parent;
6695    else {
6696      t = parent.predicate("fhir:"+parentType+'.'+name);
6697    }
6698    composeBackboneElement(t, "unmapped", name, element, index);
6699    if (element.hasModeElement()) {
6700      composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1);
6701    }
6702    if (element.hasCodeElement()) {
6703      composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1);
6704    }
6705    if (element.hasDisplayElement()) {
6706      composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1);
6707    }
6708    if (element.hasUrlElement()) {
6709      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "url", element.getUrlElement(), -1);
6710    }
6711  }
6712
6713  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
6714    if (element == null) 
6715      return;
6716    Complex t;
6717    if (Utilities.noString(parentType))
6718      t = parent;
6719    else {
6720      t = parent.predicate("fhir:"+parentType+'.'+name);
6721    }
6722    composeDomainResource(t, "Condition", name, element, index);
6723    for (int i = 0; i < element.getIdentifier().size(); i++) {
6724      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
6725    }
6726    if (element.hasClinicalStatus()) {
6727      composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1);
6728    }
6729    if (element.hasVerificationStatus()) {
6730      composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1);
6731    }
6732    for (int i = 0; i < element.getCategory().size(); i++) {
6733      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
6734    }
6735    if (element.hasSeverity()) {
6736      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
6737    }
6738    if (element.hasCode()) {
6739      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
6740    }
6741    for (int i = 0; i < element.getBodySite().size(); i++) {
6742      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
6743    }
6744    if (element.hasSubject()) {
6745      composeReference(t, "Condition", "subject", element.getSubject(), -1);
6746    }
6747    if (element.hasEncounter()) {
6748      composeReference(t, "Condition", "encounter", element.getEncounter(), -1);
6749    }
6750    if (element.hasOnset()) {
6751      composeType(t, "Condition", "onset", element.getOnset(), -1);
6752    }
6753    if (element.hasAbatement()) {
6754      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
6755    }
6756    if (element.hasRecordedDateElement()) {
6757      composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1);
6758    }
6759    if (element.hasRecorder()) {
6760      composeReference(t, "Condition", "recorder", element.getRecorder(), -1);
6761    }
6762    if (element.hasAsserter()) {
6763      composeReference(t, "Condition", "asserter", element.getAsserter(), -1);
6764    }
6765    for (int i = 0; i < element.getStage().size(); i++) {
6766      composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i);
6767    }
6768    for (int i = 0; i < element.getEvidence().size(); i++) {
6769      composeConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i);
6770    }
6771    for (int i = 0; i < element.getNote().size(); i++) {
6772      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
6773    }
6774  }
6775
6776  protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
6777    if (element == null) 
6778      return;
6779    Complex t;
6780    if (Utilities.noString(parentType))
6781      t = parent;
6782    else {
6783      t = parent.predicate("fhir:"+parentType+'.'+name);
6784    }
6785    composeBackboneElement(t, "stage", name, element, index);
6786    if (element.hasSummary()) {
6787      composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1);
6788    }
6789    for (int i = 0; i < element.getAssessment().size(); i++) {
6790      composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i);
6791    }
6792    if (element.hasType()) {
6793      composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1);
6794    }
6795  }
6796
6797  protected void composeConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) {
6798    if (element == null) 
6799      return;
6800    Complex t;
6801    if (Utilities.noString(parentType))
6802      t = parent;
6803    else {
6804      t = parent.predicate("fhir:"+parentType+'.'+name);
6805    }
6806    composeBackboneElement(t, "evidence", name, element, index);
6807    for (int i = 0; i < element.getCode().size(); i++) {
6808      composeCodeableConcept(t, "ConditionEvidenceComponent", "code", element.getCode().get(i), i);
6809    }
6810    for (int i = 0; i < element.getDetail().size(); i++) {
6811      composeReference(t, "ConditionEvidenceComponent", "detail", element.getDetail().get(i), i);
6812    }
6813  }
6814
6815  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
6816    if (element == null) 
6817      return;
6818    Complex t;
6819    if (Utilities.noString(parentType))
6820      t = parent;
6821    else {
6822      t = parent.predicate("fhir:"+parentType+'.'+name);
6823    }
6824    composeDomainResource(t, "Consent", name, element, index);
6825    for (int i = 0; i < element.getIdentifier().size(); i++) {
6826      composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i);
6827    }
6828    if (element.hasStatusElement()) {
6829      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
6830    }
6831    if (element.hasScope()) {
6832      composeCodeableConcept(t, "Consent", "scope", element.getScope(), -1);
6833    }
6834    for (int i = 0; i < element.getCategory().size(); i++) {
6835      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
6836    }
6837    if (element.hasPatient()) {
6838      composeReference(t, "Consent", "patient", element.getPatient(), -1);
6839    }
6840    if (element.hasDateTimeElement()) {
6841      composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1);
6842    }
6843    for (int i = 0; i < element.getPerformer().size(); i++) {
6844      composeReference(t, "Consent", "performer", element.getPerformer().get(i), i);
6845    }
6846    for (int i = 0; i < element.getOrganization().size(); i++) {
6847      composeReference(t, "Consent", "organization", element.getOrganization().get(i), i);
6848    }
6849    if (element.hasSource()) {
6850      composeType(t, "Consent", "source", element.getSource(), -1);
6851    }
6852    for (int i = 0; i < element.getPolicy().size(); i++) {
6853      composeConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i);
6854    }
6855    if (element.hasPolicyRule()) {
6856      composeCodeableConcept(t, "Consent", "policyRule", element.getPolicyRule(), -1);
6857    }
6858    for (int i = 0; i < element.getVerification().size(); i++) {
6859      composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i);
6860    }
6861    if (element.hasProvision()) {
6862      composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision(), -1);
6863    }
6864  }
6865
6866  protected void composeConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) {
6867    if (element == null) 
6868      return;
6869    Complex t;
6870    if (Utilities.noString(parentType))
6871      t = parent;
6872    else {
6873      t = parent.predicate("fhir:"+parentType+'.'+name);
6874    }
6875    composeBackboneElement(t, "policy", name, element, index);
6876    if (element.hasAuthorityElement()) {
6877      composeUri(t, "ConsentPolicyComponent", "authority", element.getAuthorityElement(), -1);
6878    }
6879    if (element.hasUriElement()) {
6880      composeUri(t, "ConsentPolicyComponent", "uri", element.getUriElement(), -1);
6881    }
6882  }
6883
6884  protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) {
6885    if (element == null) 
6886      return;
6887    Complex t;
6888    if (Utilities.noString(parentType))
6889      t = parent;
6890    else {
6891      t = parent.predicate("fhir:"+parentType+'.'+name);
6892    }
6893    composeBackboneElement(t, "verification", name, element, index);
6894    if (element.hasVerifiedElement()) {
6895      composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1);
6896    }
6897    if (element.hasVerifiedWith()) {
6898      composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1);
6899    }
6900    if (element.hasVerificationDateElement()) {
6901      composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDateElement(), -1);
6902    }
6903  }
6904
6905  protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) {
6906    if (element == null) 
6907      return;
6908    Complex t;
6909    if (Utilities.noString(parentType))
6910      t = parent;
6911    else {
6912      t = parent.predicate("fhir:"+parentType+'.'+name);
6913    }
6914    composeBackboneElement(t, "provision", name, element, index);
6915    if (element.hasTypeElement()) {
6916      composeEnum(t, "ProvisionComponent", "type", element.getTypeElement(), -1);
6917    }
6918    if (element.hasPeriod()) {
6919      composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1);
6920    }
6921    for (int i = 0; i < element.getActor().size(); i++) {
6922      composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i);
6923    }
6924    for (int i = 0; i < element.getAction().size(); i++) {
6925      composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i);
6926    }
6927    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
6928      composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i);
6929    }
6930    for (int i = 0; i < element.getPurpose().size(); i++) {
6931      composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i);
6932    }
6933    for (int i = 0; i < element.getClass_().size(); i++) {
6934      composeCoding(t, "ProvisionComponent", "class", element.getClass_().get(i), i);
6935    }
6936    for (int i = 0; i < element.getCode().size(); i++) {
6937      composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i);
6938    }
6939    if (element.hasDataPeriod()) {
6940      composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1);
6941    }
6942    for (int i = 0; i < element.getData().size(); i++) {
6943      composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i);
6944    }
6945    for (int i = 0; i < element.getProvision().size(); i++) {
6946      composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i);
6947    }
6948  }
6949
6950  protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) {
6951    if (element == null) 
6952      return;
6953    Complex t;
6954    if (Utilities.noString(parentType))
6955      t = parent;
6956    else {
6957      t = parent.predicate("fhir:"+parentType+'.'+name);
6958    }
6959    composeBackboneElement(t, "actor", name, element, index);
6960    if (element.hasRole()) {
6961      composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1);
6962    }
6963    if (element.hasReference()) {
6964      composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1);
6965    }
6966  }
6967
6968  protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent element, int index) {
6969    if (element == null) 
6970      return;
6971    Complex t;
6972    if (Utilities.noString(parentType))
6973      t = parent;
6974    else {
6975      t = parent.predicate("fhir:"+parentType+'.'+name);
6976    }
6977    composeBackboneElement(t, "data", name, element, index);
6978    if (element.hasMeaningElement()) {
6979      composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1);
6980    }
6981    if (element.hasReference()) {
6982      composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1);
6983    }
6984  }
6985
6986  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
6987    if (element == null) 
6988      return;
6989    Complex t;
6990    if (Utilities.noString(parentType))
6991      t = parent;
6992    else {
6993      t = parent.predicate("fhir:"+parentType+'.'+name);
6994    }
6995    composeDomainResource(t, "Contract", name, element, index);
6996    for (int i = 0; i < element.getIdentifier().size(); i++) {
6997      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
6998    }
6999    if (element.hasUrlElement()) {
7000      composeUri(t, "Contract", "url", element.getUrlElement(), -1);
7001    }
7002    if (element.hasVersionElement()) {
7003      composeString(t, "Contract", "version", element.getVersionElement(), -1);
7004    }
7005    if (element.hasStatusElement()) {
7006      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
7007    }
7008    if (element.hasLegalState()) {
7009      composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1);
7010    }
7011    if (element.hasInstantiatesCanonical()) {
7012      composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1);
7013    }
7014    if (element.hasInstantiatesUriElement()) {
7015      composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1);
7016    }
7017    if (element.hasContentDerivative()) {
7018      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
7019    }
7020    if (element.hasIssuedElement()) {
7021      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
7022    }
7023    if (element.hasApplies()) {
7024      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
7025    }
7026    if (element.hasExpirationType()) {
7027      composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1);
7028    }
7029    for (int i = 0; i < element.getSubject().size(); i++) {
7030      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
7031    }
7032    for (int i = 0; i < element.getAuthority().size(); i++) {
7033      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
7034    }
7035    for (int i = 0; i < element.getDomain().size(); i++) {
7036      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
7037    }
7038    for (int i = 0; i < element.getSite().size(); i++) {
7039      composeReference(t, "Contract", "site", element.getSite().get(i), i);
7040    }
7041    if (element.hasNameElement()) {
7042      composeString(t, "Contract", "name", element.getNameElement(), -1);
7043    }
7044    if (element.hasTitleElement()) {
7045      composeString(t, "Contract", "title", element.getTitleElement(), -1);
7046    }
7047    if (element.hasSubtitleElement()) {
7048      composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1);
7049    }
7050    for (int i = 0; i < element.getAlias().size(); i++) {
7051      composeString(t, "Contract", "alias", element.getAlias().get(i), i);
7052    }
7053    if (element.hasAuthor()) {
7054      composeReference(t, "Contract", "author", element.getAuthor(), -1);
7055    }
7056    if (element.hasScope()) {
7057      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
7058    }
7059    if (element.hasTopic()) {
7060      composeType(t, "Contract", "topic", element.getTopic(), -1);
7061    }
7062    if (element.hasType()) {
7063      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
7064    }
7065    for (int i = 0; i < element.getSubType().size(); i++) {
7066      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
7067    }
7068    if (element.hasContentDefinition()) {
7069      composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1);
7070    }
7071    for (int i = 0; i < element.getTerm().size(); i++) {
7072      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
7073    }
7074    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
7075      composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i);
7076    }
7077    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
7078      composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i);
7079    }
7080    for (int i = 0; i < element.getSigner().size(); i++) {
7081      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
7082    }
7083    for (int i = 0; i < element.getFriendly().size(); i++) {
7084      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
7085    }
7086    for (int i = 0; i < element.getLegal().size(); i++) {
7087      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
7088    }
7089    for (int i = 0; i < element.getRule().size(); i++) {
7090      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
7091    }
7092    if (element.hasLegallyBinding()) {
7093      composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1);
7094    }
7095  }
7096
7097  protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) {
7098    if (element == null) 
7099      return;
7100    Complex t;
7101    if (Utilities.noString(parentType))
7102      t = parent;
7103    else {
7104      t = parent.predicate("fhir:"+parentType+'.'+name);
7105    }
7106    composeBackboneElement(t, "contentDefinition", name, element, index);
7107    if (element.hasType()) {
7108      composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1);
7109    }
7110    if (element.hasSubType()) {
7111      composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1);
7112    }
7113    if (element.hasPublisher()) {
7114      composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1);
7115    }
7116    if (element.hasPublicationDateElement()) {
7117      composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1);
7118    }
7119    if (element.hasPublicationStatusElement()) {
7120      composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1);
7121    }
7122    if (element.hasCopyrightElement()) {
7123      composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1);
7124    }
7125  }
7126
7127  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
7128    if (element == null) 
7129      return;
7130    Complex t;
7131    if (Utilities.noString(parentType))
7132      t = parent;
7133    else {
7134      t = parent.predicate("fhir:"+parentType+'.'+name);
7135    }
7136    composeBackboneElement(t, "term", name, element, index);
7137    if (element.hasIdentifier()) {
7138      composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1);
7139    }
7140    if (element.hasIssuedElement()) {
7141      composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1);
7142    }
7143    if (element.hasApplies()) {
7144      composePeriod(t, "TermComponent", "applies", element.getApplies(), -1);
7145    }
7146    if (element.hasTopic()) {
7147      composeType(t, "TermComponent", "topic", element.getTopic(), -1);
7148    }
7149    if (element.hasType()) {
7150      composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1);
7151    }
7152    if (element.hasSubType()) {
7153      composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1);
7154    }
7155    if (element.hasTextElement()) {
7156      composeString(t, "TermComponent", "text", element.getTextElement(), -1);
7157    }
7158    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
7159      composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i);
7160    }
7161    if (element.hasOffer()) {
7162      composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1);
7163    }
7164    for (int i = 0; i < element.getAsset().size(); i++) {
7165      composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i);
7166    }
7167    for (int i = 0; i < element.getAction().size(); i++) {
7168      composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i);
7169    }
7170    for (int i = 0; i < element.getGroup().size(); i++) {
7171      composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i);
7172    }
7173  }
7174
7175  protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) {
7176    if (element == null) 
7177      return;
7178    Complex t;
7179    if (Utilities.noString(parentType))
7180      t = parent;
7181    else {
7182      t = parent.predicate("fhir:"+parentType+'.'+name);
7183    }
7184    composeBackboneElement(t, "securityLabel", name, element, index);
7185    for (int i = 0; i < element.getNumber().size(); i++) {
7186      composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i);
7187    }
7188    if (element.hasClassification()) {
7189      composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1);
7190    }
7191    for (int i = 0; i < element.getCategory().size(); i++) {
7192      composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i);
7193    }
7194    for (int i = 0; i < element.getControl().size(); i++) {
7195      composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i);
7196    }
7197  }
7198
7199  protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) {
7200    if (element == null) 
7201      return;
7202    Complex t;
7203    if (Utilities.noString(parentType))
7204      t = parent;
7205    else {
7206      t = parent.predicate("fhir:"+parentType+'.'+name);
7207    }
7208    composeBackboneElement(t, "offer", name, element, index);
7209    for (int i = 0; i < element.getIdentifier().size(); i++) {
7210      composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i);
7211    }
7212    for (int i = 0; i < element.getParty().size(); i++) {
7213      composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i);
7214    }
7215    if (element.hasTopic()) {
7216      composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1);
7217    }
7218    if (element.hasType()) {
7219      composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1);
7220    }
7221    if (element.hasDecision()) {
7222      composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1);
7223    }
7224    for (int i = 0; i < element.getDecisionMode().size(); i++) {
7225      composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i);
7226    }
7227    for (int i = 0; i < element.getAnswer().size(); i++) {
7228      composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i);
7229    }
7230    if (element.hasTextElement()) {
7231      composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1);
7232    }
7233    for (int i = 0; i < element.getLinkId().size(); i++) {
7234      composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i);
7235    }
7236    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7237      composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7238    }
7239  }
7240
7241  protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) {
7242    if (element == null) 
7243      return;
7244    Complex t;
7245    if (Utilities.noString(parentType))
7246      t = parent;
7247    else {
7248      t = parent.predicate("fhir:"+parentType+'.'+name);
7249    }
7250    composeBackboneElement(t, "party", name, element, index);
7251    for (int i = 0; i < element.getReference().size(); i++) {
7252      composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i);
7253    }
7254    if (element.hasRole()) {
7255      composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1);
7256    }
7257  }
7258
7259  protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) {
7260    if (element == null) 
7261      return;
7262    Complex t;
7263    if (Utilities.noString(parentType))
7264      t = parent;
7265    else {
7266      t = parent.predicate("fhir:"+parentType+'.'+name);
7267    }
7268    composeBackboneElement(t, "answer", name, element, index);
7269    if (element.hasValue()) {
7270      composeType(t, "AnswerComponent", "value", element.getValue(), -1);
7271    }
7272  }
7273
7274  protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) {
7275    if (element == null) 
7276      return;
7277    Complex t;
7278    if (Utilities.noString(parentType))
7279      t = parent;
7280    else {
7281      t = parent.predicate("fhir:"+parentType+'.'+name);
7282    }
7283    composeBackboneElement(t, "asset", name, element, index);
7284    if (element.hasScope()) {
7285      composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1);
7286    }
7287    for (int i = 0; i < element.getType().size(); i++) {
7288      composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i);
7289    }
7290    for (int i = 0; i < element.getTypeReference().size(); i++) {
7291      composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i);
7292    }
7293    for (int i = 0; i < element.getSubtype().size(); i++) {
7294      composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i);
7295    }
7296    if (element.hasRelationship()) {
7297      composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1);
7298    }
7299    for (int i = 0; i < element.getContext().size(); i++) {
7300      composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i);
7301    }
7302    if (element.hasConditionElement()) {
7303      composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1);
7304    }
7305    for (int i = 0; i < element.getPeriodType().size(); i++) {
7306      composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i);
7307    }
7308    for (int i = 0; i < element.getPeriod().size(); i++) {
7309      composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i);
7310    }
7311    for (int i = 0; i < element.getUsePeriod().size(); i++) {
7312      composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i);
7313    }
7314    if (element.hasTextElement()) {
7315      composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1);
7316    }
7317    for (int i = 0; i < element.getLinkId().size(); i++) {
7318      composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i);
7319    }
7320    for (int i = 0; i < element.getAnswer().size(); i++) {
7321      composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i);
7322    }
7323    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7324      composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7325    }
7326    for (int i = 0; i < element.getValuedItem().size(); i++) {
7327      composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i);
7328    }
7329  }
7330
7331  protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) {
7332    if (element == null) 
7333      return;
7334    Complex t;
7335    if (Utilities.noString(parentType))
7336      t = parent;
7337    else {
7338      t = parent.predicate("fhir:"+parentType+'.'+name);
7339    }
7340    composeBackboneElement(t, "context", name, element, index);
7341    if (element.hasReference()) {
7342      composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1);
7343    }
7344    for (int i = 0; i < element.getCode().size(); i++) {
7345      composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i);
7346    }
7347    if (element.hasTextElement()) {
7348      composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1);
7349    }
7350  }
7351
7352  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) {
7353    if (element == null) 
7354      return;
7355    Complex t;
7356    if (Utilities.noString(parentType))
7357      t = parent;
7358    else {
7359      t = parent.predicate("fhir:"+parentType+'.'+name);
7360    }
7361    composeBackboneElement(t, "valuedItem", name, element, index);
7362    if (element.hasEntity()) {
7363      composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1);
7364    }
7365    if (element.hasIdentifier()) {
7366      composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1);
7367    }
7368    if (element.hasEffectiveTimeElement()) {
7369      composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1);
7370    }
7371    if (element.hasQuantity()) {
7372      composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1);
7373    }
7374    if (element.hasUnitPrice()) {
7375      composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1);
7376    }
7377    if (element.hasFactorElement()) {
7378      composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1);
7379    }
7380    if (element.hasPointsElement()) {
7381      composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1);
7382    }
7383    if (element.hasNet()) {
7384      composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1);
7385    }
7386    if (element.hasPaymentElement()) {
7387      composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1);
7388    }
7389    if (element.hasPaymentDateElement()) {
7390      composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1);
7391    }
7392    if (element.hasResponsible()) {
7393      composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1);
7394    }
7395    if (element.hasRecipient()) {
7396      composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1);
7397    }
7398    for (int i = 0; i < element.getLinkId().size(); i++) {
7399      composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i);
7400    }
7401    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7402      composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7403    }
7404  }
7405
7406  protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) {
7407    if (element == null) 
7408      return;
7409    Complex t;
7410    if (Utilities.noString(parentType))
7411      t = parent;
7412    else {
7413      t = parent.predicate("fhir:"+parentType+'.'+name);
7414    }
7415    composeBackboneElement(t, "action", name, element, index);
7416    if (element.hasDoNotPerformElement()) {
7417      composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
7418    }
7419    if (element.hasType()) {
7420      composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1);
7421    }
7422    for (int i = 0; i < element.getSubject().size(); i++) {
7423      composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i);
7424    }
7425    if (element.hasIntent()) {
7426      composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1);
7427    }
7428    for (int i = 0; i < element.getLinkId().size(); i++) {
7429      composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i);
7430    }
7431    if (element.hasStatus()) {
7432      composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1);
7433    }
7434    if (element.hasContext()) {
7435      composeReference(t, "ActionComponent", "context", element.getContext(), -1);
7436    }
7437    for (int i = 0; i < element.getContextLinkId().size(); i++) {
7438      composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i);
7439    }
7440    if (element.hasOccurrence()) {
7441      composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1);
7442    }
7443    for (int i = 0; i < element.getRequester().size(); i++) {
7444      composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i);
7445    }
7446    for (int i = 0; i < element.getRequesterLinkId().size(); i++) {
7447      composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i);
7448    }
7449    for (int i = 0; i < element.getPerformerType().size(); i++) {
7450      composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i);
7451    }
7452    if (element.hasPerformerRole()) {
7453      composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1);
7454    }
7455    if (element.hasPerformer()) {
7456      composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1);
7457    }
7458    for (int i = 0; i < element.getPerformerLinkId().size(); i++) {
7459      composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i);
7460    }
7461    for (int i = 0; i < element.getReasonCode().size(); i++) {
7462      composeCodeableConcept(t, "ActionComponent", "reasonCode", element.getReasonCode().get(i), i);
7463    }
7464    for (int i = 0; i < element.getReasonReference().size(); i++) {
7465      composeReference(t, "ActionComponent", "reasonReference", element.getReasonReference().get(i), i);
7466    }
7467    for (int i = 0; i < element.getReason().size(); i++) {
7468      composeString(t, "ActionComponent", "reason", element.getReason().get(i), i);
7469    }
7470    for (int i = 0; i < element.getReasonLinkId().size(); i++) {
7471      composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i);
7472    }
7473    for (int i = 0; i < element.getNote().size(); i++) {
7474      composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i);
7475    }
7476    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7477      composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7478    }
7479  }
7480
7481  protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) {
7482    if (element == null) 
7483      return;
7484    Complex t;
7485    if (Utilities.noString(parentType))
7486      t = parent;
7487    else {
7488      t = parent.predicate("fhir:"+parentType+'.'+name);
7489    }
7490    composeBackboneElement(t, "subject", name, element, index);
7491    for (int i = 0; i < element.getReference().size(); i++) {
7492      composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i);
7493    }
7494    if (element.hasRole()) {
7495      composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1);
7496    }
7497  }
7498
7499  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
7500    if (element == null) 
7501      return;
7502    Complex t;
7503    if (Utilities.noString(parentType))
7504      t = parent;
7505    else {
7506      t = parent.predicate("fhir:"+parentType+'.'+name);
7507    }
7508    composeBackboneElement(t, "signer", name, element, index);
7509    if (element.hasType()) {
7510      composeCoding(t, "SignatoryComponent", "type", element.getType(), -1);
7511    }
7512    if (element.hasParty()) {
7513      composeReference(t, "SignatoryComponent", "party", element.getParty(), -1);
7514    }
7515    for (int i = 0; i < element.getSignature().size(); i++) {
7516      composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i);
7517    }
7518  }
7519
7520  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
7521    if (element == null) 
7522      return;
7523    Complex t;
7524    if (Utilities.noString(parentType))
7525      t = parent;
7526    else {
7527      t = parent.predicate("fhir:"+parentType+'.'+name);
7528    }
7529    composeBackboneElement(t, "friendly", name, element, index);
7530    if (element.hasContent()) {
7531      composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1);
7532    }
7533  }
7534
7535  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
7536    if (element == null) 
7537      return;
7538    Complex t;
7539    if (Utilities.noString(parentType))
7540      t = parent;
7541    else {
7542      t = parent.predicate("fhir:"+parentType+'.'+name);
7543    }
7544    composeBackboneElement(t, "legal", name, element, index);
7545    if (element.hasContent()) {
7546      composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1);
7547    }
7548  }
7549
7550  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
7551    if (element == null) 
7552      return;
7553    Complex t;
7554    if (Utilities.noString(parentType))
7555      t = parent;
7556    else {
7557      t = parent.predicate("fhir:"+parentType+'.'+name);
7558    }
7559    composeBackboneElement(t, "rule", name, element, index);
7560    if (element.hasContent()) {
7561      composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1);
7562    }
7563  }
7564
7565  protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) {
7566    if (element == null) 
7567      return;
7568    Complex t;
7569    if (Utilities.noString(parentType))
7570      t = parent;
7571    else {
7572      t = parent.predicate("fhir:"+parentType+'.'+name);
7573    }
7574    composeDomainResource(t, "Coverage", name, element, index);
7575    for (int i = 0; i < element.getIdentifier().size(); i++) {
7576      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
7577    }
7578    if (element.hasStatusElement()) {
7579      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
7580    }
7581    if (element.hasType()) {
7582      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
7583    }
7584    if (element.hasPolicyHolder()) {
7585      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
7586    }
7587    if (element.hasSubscriber()) {
7588      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
7589    }
7590    if (element.hasSubscriberIdElement()) {
7591      composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1);
7592    }
7593    if (element.hasBeneficiary()) {
7594      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
7595    }
7596    if (element.hasDependentElement()) {
7597      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
7598    }
7599    if (element.hasRelationship()) {
7600      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
7601    }
7602    if (element.hasPeriod()) {
7603      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
7604    }
7605    for (int i = 0; i < element.getPayor().size(); i++) {
7606      composeReference(t, "Coverage", "payor", element.getPayor().get(i), i);
7607    }
7608    for (int i = 0; i < element.getClass_().size(); i++) {
7609      composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i);
7610    }
7611    if (element.hasOrderElement()) {
7612      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
7613    }
7614    if (element.hasNetworkElement()) {
7615      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
7616    }
7617    for (int i = 0; i < element.getCostToBeneficiary().size(); i++) {
7618      composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i);
7619    }
7620    if (element.hasSubrogationElement()) {
7621      composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1);
7622    }
7623    for (int i = 0; i < element.getContract().size(); i++) {
7624      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
7625    }
7626  }
7627
7628  protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) {
7629    if (element == null) 
7630      return;
7631    Complex t;
7632    if (Utilities.noString(parentType))
7633      t = parent;
7634    else {
7635      t = parent.predicate("fhir:"+parentType+'.'+name);
7636    }
7637    composeBackboneElement(t, "class", name, element, index);
7638    if (element.hasType()) {
7639      composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1);
7640    }
7641    if (element.hasValueElement()) {
7642      composeString(t, "ClassComponent", "value", element.getValueElement(), -1);
7643    }
7644    if (element.hasNameElement()) {
7645      composeString(t, "ClassComponent", "name", element.getNameElement(), -1);
7646    }
7647  }
7648
7649  protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) {
7650    if (element == null) 
7651      return;
7652    Complex t;
7653    if (Utilities.noString(parentType))
7654      t = parent;
7655    else {
7656      t = parent.predicate("fhir:"+parentType+'.'+name);
7657    }
7658    composeBackboneElement(t, "costToBeneficiary", name, element, index);
7659    if (element.hasType()) {
7660      composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1);
7661    }
7662    if (element.hasValue()) {
7663      composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1);
7664    }
7665    for (int i = 0; i < element.getException().size(); i++) {
7666      composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i);
7667    }
7668  }
7669
7670  protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) {
7671    if (element == null) 
7672      return;
7673    Complex t;
7674    if (Utilities.noString(parentType))
7675      t = parent;
7676    else {
7677      t = parent.predicate("fhir:"+parentType+'.'+name);
7678    }
7679    composeBackboneElement(t, "exception", name, element, index);
7680    if (element.hasType()) {
7681      composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1);
7682    }
7683    if (element.hasPeriod()) {
7684      composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1);
7685    }
7686  }
7687
7688  protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) {
7689    if (element == null) 
7690      return;
7691    Complex t;
7692    if (Utilities.noString(parentType))
7693      t = parent;
7694    else {
7695      t = parent.predicate("fhir:"+parentType+'.'+name);
7696    }
7697    composeDomainResource(t, "CoverageEligibilityRequest", name, element, index);
7698    for (int i = 0; i < element.getIdentifier().size(); i++) {
7699      composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i);
7700    }
7701    if (element.hasStatusElement()) {
7702      composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1);
7703    }
7704    if (element.hasPriority()) {
7705      composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1);
7706    }
7707    for (int i = 0; i < element.getPurpose().size(); i++) {
7708      composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i);
7709    }
7710    if (element.hasPatient()) {
7711      composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1);
7712    }
7713    if (element.hasServiced()) {
7714      composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1);
7715    }
7716    if (element.hasCreatedElement()) {
7717      composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1);
7718    }
7719    if (element.hasEnterer()) {
7720      composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1);
7721    }
7722    if (element.hasProvider()) {
7723      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
7724    }
7725    if (element.hasInsurer()) {
7726      composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1);
7727    }
7728    if (element.hasFacility()) {
7729      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
7730    }
7731    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
7732      composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
7733    }
7734    for (int i = 0; i < element.getInsurance().size(); i++) {
7735      composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i);
7736    }
7737    for (int i = 0; i < element.getItem().size(); i++) {
7738      composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i);
7739    }
7740  }
7741
7742  protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) {
7743    if (element == null) 
7744      return;
7745    Complex t;
7746    if (Utilities.noString(parentType))
7747      t = parent;
7748    else {
7749      t = parent.predicate("fhir:"+parentType+'.'+name);
7750    }
7751    composeBackboneElement(t, "supportingInfo", name, element, index);
7752    if (element.hasSequenceElement()) {
7753      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
7754    }
7755    if (element.hasInformation()) {
7756      composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1);
7757    }
7758    if (element.hasAppliesToAllElement()) {
7759      composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1);
7760    }
7761  }
7762
7763  protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) {
7764    if (element == null) 
7765      return;
7766    Complex t;
7767    if (Utilities.noString(parentType))
7768      t = parent;
7769    else {
7770      t = parent.predicate("fhir:"+parentType+'.'+name);
7771    }
7772    composeBackboneElement(t, "insurance", name, element, index);
7773    if (element.hasFocalElement()) {
7774      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
7775    }
7776    if (element.hasCoverage()) {
7777      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
7778    }
7779    if (element.hasBusinessArrangementElement()) {
7780      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
7781    }
7782  }
7783
7784  protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) {
7785    if (element == null) 
7786      return;
7787    Complex t;
7788    if (Utilities.noString(parentType))
7789      t = parent;
7790    else {
7791      t = parent.predicate("fhir:"+parentType+'.'+name);
7792    }
7793    composeBackboneElement(t, "item", name, element, index);
7794    for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) {
7795      composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i);
7796    }
7797    if (element.hasCategory()) {
7798      composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1);
7799    }
7800    if (element.hasProductOrService()) {
7801      composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1);
7802    }
7803    for (int i = 0; i < element.getModifier().size(); i++) {
7804      composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i);
7805    }
7806    if (element.hasProvider()) {
7807      composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1);
7808    }
7809    if (element.hasQuantity()) {
7810      composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1);
7811    }
7812    if (element.hasUnitPrice()) {
7813      composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1);
7814    }
7815    if (element.hasFacility()) {
7816      composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1);
7817    }
7818    for (int i = 0; i < element.getDiagnosis().size(); i++) {
7819      composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i);
7820    }
7821    for (int i = 0; i < element.getDetail().size(); i++) {
7822      composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i);
7823    }
7824  }
7825
7826  protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) {
7827    if (element == null) 
7828      return;
7829    Complex t;
7830    if (Utilities.noString(parentType))
7831      t = parent;
7832    else {
7833      t = parent.predicate("fhir:"+parentType+'.'+name);
7834    }
7835    composeBackboneElement(t, "diagnosis", name, element, index);
7836    if (element.hasDiagnosis()) {
7837      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
7838    }
7839  }
7840
7841  protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) {
7842    if (element == null) 
7843      return;
7844    Complex t;
7845    if (Utilities.noString(parentType))
7846      t = parent;
7847    else {
7848      t = parent.predicate("fhir:"+parentType+'.'+name);
7849    }
7850    composeDomainResource(t, "CoverageEligibilityResponse", name, element, index);
7851    for (int i = 0; i < element.getIdentifier().size(); i++) {
7852      composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i);
7853    }
7854    if (element.hasStatusElement()) {
7855      composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1);
7856    }
7857    for (int i = 0; i < element.getPurpose().size(); i++) {
7858      composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i);
7859    }
7860    if (element.hasPatient()) {
7861      composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1);
7862    }
7863    if (element.hasServiced()) {
7864      composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1);
7865    }
7866    if (element.hasCreatedElement()) {
7867      composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1);
7868    }
7869    if (element.hasRequestor()) {
7870      composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1);
7871    }
7872    if (element.hasRequest()) {
7873      composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1);
7874    }
7875    if (element.hasOutcomeElement()) {
7876      composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1);
7877    }
7878    if (element.hasDispositionElement()) {
7879      composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1);
7880    }
7881    if (element.hasInsurer()) {
7882      composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1);
7883    }
7884    for (int i = 0; i < element.getInsurance().size(); i++) {
7885      composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i);
7886    }
7887    if (element.hasPreAuthRefElement()) {
7888      composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
7889    }
7890    if (element.hasForm()) {
7891      composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1);
7892    }
7893    for (int i = 0; i < element.getError().size(); i++) {
7894      composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i);
7895    }
7896  }
7897
7898  protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) {
7899    if (element == null) 
7900      return;
7901    Complex t;
7902    if (Utilities.noString(parentType))
7903      t = parent;
7904    else {
7905      t = parent.predicate("fhir:"+parentType+'.'+name);
7906    }
7907    composeBackboneElement(t, "insurance", name, element, index);
7908    if (element.hasCoverage()) {
7909      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
7910    }
7911    if (element.hasInforceElement()) {
7912      composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1);
7913    }
7914    if (element.hasBenefitPeriod()) {
7915      composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1);
7916    }
7917    for (int i = 0; i < element.getItem().size(); i++) {
7918      composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i);
7919    }
7920  }
7921
7922  protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) {
7923    if (element == null) 
7924      return;
7925    Complex t;
7926    if (Utilities.noString(parentType))
7927      t = parent;
7928    else {
7929      t = parent.predicate("fhir:"+parentType+'.'+name);
7930    }
7931    composeBackboneElement(t, "item", name, element, index);
7932    if (element.hasCategory()) {
7933      composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1);
7934    }
7935    if (element.hasProductOrService()) {
7936      composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1);
7937    }
7938    for (int i = 0; i < element.getModifier().size(); i++) {
7939      composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i);
7940    }
7941    if (element.hasProvider()) {
7942      composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1);
7943    }
7944    if (element.hasExcludedElement()) {
7945      composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1);
7946    }
7947    if (element.hasNameElement()) {
7948      composeString(t, "ItemsComponent", "name", element.getNameElement(), -1);
7949    }
7950    if (element.hasDescriptionElement()) {
7951      composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1);
7952    }
7953    if (element.hasNetwork()) {
7954      composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1);
7955    }
7956    if (element.hasUnit()) {
7957      composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1);
7958    }
7959    if (element.hasTerm()) {
7960      composeCodeableConcept(t, "ItemsComponent", "term", element.getTerm(), -1);
7961    }
7962    for (int i = 0; i < element.getBenefit().size(); i++) {
7963      composeCoverageEligibilityResponseBenefitComponent(t, "ItemsComponent", "benefit", element.getBenefit().get(i), i);
7964    }
7965    if (element.hasAuthorizationRequiredElement()) {
7966      composeBoolean(t, "ItemsComponent", "authorizationRequired", element.getAuthorizationRequiredElement(), -1);
7967    }
7968    for (int i = 0; i < element.getAuthorizationSupporting().size(); i++) {
7969      composeCodeableConcept(t, "ItemsComponent", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i);
7970    }
7971    if (element.hasAuthorizationUrlElement()) {
7972      composeUri(t, "ItemsComponent", "authorizationUrl", element.getAuthorizationUrlElement(), -1);
7973    }
7974  }
7975
7976  protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent element, int index) {
7977    if (element == null) 
7978      return;
7979    Complex t;
7980    if (Utilities.noString(parentType))
7981      t = parent;
7982    else {
7983      t = parent.predicate("fhir:"+parentType+'.'+name);
7984    }
7985    composeBackboneElement(t, "benefit", name, element, index);
7986    if (element.hasType()) {
7987      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
7988    }
7989    if (element.hasAllowed()) {
7990      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
7991    }
7992    if (element.hasUsed()) {
7993      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
7994    }
7995  }
7996
7997  protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent element, int index) {
7998    if (element == null) 
7999      return;
8000    Complex t;
8001    if (Utilities.noString(parentType))
8002      t = parent;
8003    else {
8004      t = parent.predicate("fhir:"+parentType+'.'+name);
8005    }
8006    composeBackboneElement(t, "error", name, element, index);
8007    if (element.hasCode()) {
8008      composeCodeableConcept(t, "ErrorsComponent", "code", element.getCode(), -1);
8009    }
8010  }
8011
8012  protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) {
8013    if (element == null) 
8014      return;
8015    Complex t;
8016    if (Utilities.noString(parentType))
8017      t = parent;
8018    else {
8019      t = parent.predicate("fhir:"+parentType+'.'+name);
8020    }
8021    composeDomainResource(t, "DetectedIssue", name, element, index);
8022    for (int i = 0; i < element.getIdentifier().size(); i++) {
8023      composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i);
8024    }
8025    if (element.hasStatusElement()) {
8026      composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1);
8027    }
8028    if (element.hasCode()) {
8029      composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1);
8030    }
8031    if (element.hasSeverityElement()) {
8032      composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1);
8033    }
8034    if (element.hasPatient()) {
8035      composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1);
8036    }
8037    if (element.hasIdentified()) {
8038      composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1);
8039    }
8040    if (element.hasAuthor()) {
8041      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
8042    }
8043    for (int i = 0; i < element.getImplicated().size(); i++) {
8044      composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i);
8045    }
8046    for (int i = 0; i < element.getEvidence().size(); i++) {
8047      composeDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i);
8048    }
8049    if (element.hasDetailElement()) {
8050      composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1);
8051    }
8052    if (element.hasReferenceElement()) {
8053      composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1);
8054    }
8055    for (int i = 0; i < element.getMitigation().size(); i++) {
8056      composeDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i);
8057    }
8058  }
8059
8060  protected void composeDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent element, int index) {
8061    if (element == null) 
8062      return;
8063    Complex t;
8064    if (Utilities.noString(parentType))
8065      t = parent;
8066    else {
8067      t = parent.predicate("fhir:"+parentType+'.'+name);
8068    }
8069    composeBackboneElement(t, "evidence", name, element, index);
8070    for (int i = 0; i < element.getCode().size(); i++) {
8071      composeCodeableConcept(t, "DetectedIssueEvidenceComponent", "code", element.getCode().get(i), i);
8072    }
8073    for (int i = 0; i < element.getDetail().size(); i++) {
8074      composeReference(t, "DetectedIssueEvidenceComponent", "detail", element.getDetail().get(i), i);
8075    }
8076  }
8077
8078  protected void composeDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) {
8079    if (element == null) 
8080      return;
8081    Complex t;
8082    if (Utilities.noString(parentType))
8083      t = parent;
8084    else {
8085      t = parent.predicate("fhir:"+parentType+'.'+name);
8086    }
8087    composeBackboneElement(t, "mitigation", name, element, index);
8088    if (element.hasAction()) {
8089      composeCodeableConcept(t, "DetectedIssueMitigationComponent", "action", element.getAction(), -1);
8090    }
8091    if (element.hasDateElement()) {
8092      composeDateTime(t, "DetectedIssueMitigationComponent", "date", element.getDateElement(), -1);
8093    }
8094    if (element.hasAuthor()) {
8095      composeReference(t, "DetectedIssueMitigationComponent", "author", element.getAuthor(), -1);
8096    }
8097  }
8098
8099  protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) {
8100    if (element == null) 
8101      return;
8102    Complex t;
8103    if (Utilities.noString(parentType))
8104      t = parent;
8105    else {
8106      t = parent.predicate("fhir:"+parentType+'.'+name);
8107    }
8108    composeDomainResource(t, "Device", name, element, index);
8109    for (int i = 0; i < element.getIdentifier().size(); i++) {
8110      composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i);
8111    }
8112    if (element.hasDefinition()) {
8113      composeReference(t, "Device", "definition", element.getDefinition(), -1);
8114    }
8115    for (int i = 0; i < element.getUdiCarrier().size(); i++) {
8116      composeDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i);
8117    }
8118    if (element.hasStatusElement()) {
8119      composeEnum(t, "Device", "status", element.getStatusElement(), -1);
8120    }
8121    for (int i = 0; i < element.getStatusReason().size(); i++) {
8122      composeCodeableConcept(t, "Device", "statusReason", element.getStatusReason().get(i), i);
8123    }
8124    if (element.hasDistinctIdentifierElement()) {
8125      composeString(t, "Device", "distinctIdentifier", element.getDistinctIdentifierElement(), -1);
8126    }
8127    if (element.hasManufacturerElement()) {
8128      composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1);
8129    }
8130    if (element.hasManufactureDateElement()) {
8131      composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1);
8132    }
8133    if (element.hasExpirationDateElement()) {
8134      composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1);
8135    }
8136    if (element.hasLotNumberElement()) {
8137      composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1);
8138    }
8139    if (element.hasSerialNumberElement()) {
8140      composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1);
8141    }
8142    for (int i = 0; i < element.getDeviceName().size(); i++) {
8143      composeDeviceDeviceNameComponent(t, "Device", "deviceName", element.getDeviceName().get(i), i);
8144    }
8145    if (element.hasModelNumberElement()) {
8146      composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1);
8147    }
8148    if (element.hasPartNumberElement()) {
8149      composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1);
8150    }
8151    if (element.hasType()) {
8152      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
8153    }
8154    for (int i = 0; i < element.getSpecialization().size(); i++) {
8155      composeDeviceSpecializationComponent(t, "Device", "specialization", element.getSpecialization().get(i), i);
8156    }
8157    for (int i = 0; i < element.getVersion().size(); i++) {
8158      composeDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i);
8159    }
8160    for (int i = 0; i < element.getProperty().size(); i++) {
8161      composeDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i);
8162    }
8163    if (element.hasPatient()) {
8164      composeReference(t, "Device", "patient", element.getPatient(), -1);
8165    }
8166    if (element.hasOwner()) {
8167      composeReference(t, "Device", "owner", element.getOwner(), -1);
8168    }
8169    for (int i = 0; i < element.getContact().size(); i++) {
8170      composeContactPoint(t, "Device", "contact", element.getContact().get(i), i);
8171    }
8172    if (element.hasLocation()) {
8173      composeReference(t, "Device", "location", element.getLocation(), -1);
8174    }
8175    if (element.hasUrlElement()) {
8176      composeUri(t, "Device", "url", element.getUrlElement(), -1);
8177    }
8178    for (int i = 0; i < element.getNote().size(); i++) {
8179      composeAnnotation(t, "Device", "note", element.getNote().get(i), i);
8180    }
8181    for (int i = 0; i < element.getSafety().size(); i++) {
8182      composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i);
8183    }
8184    if (element.hasParent()) {
8185      composeReference(t, "Device", "parent", element.getParent(), -1);
8186    }
8187  }
8188
8189  protected void composeDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent element, int index) {
8190    if (element == null) 
8191      return;
8192    Complex t;
8193    if (Utilities.noString(parentType))
8194      t = parent;
8195    else {
8196      t = parent.predicate("fhir:"+parentType+'.'+name);
8197    }
8198    composeBackboneElement(t, "udiCarrier", name, element, index);
8199    if (element.hasDeviceIdentifierElement()) {
8200      composeString(t, "DeviceUdiCarrierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
8201    }
8202    if (element.hasIssuerElement()) {
8203      composeUri(t, "DeviceUdiCarrierComponent", "issuer", element.getIssuerElement(), -1);
8204    }
8205    if (element.hasJurisdictionElement()) {
8206      composeUri(t, "DeviceUdiCarrierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
8207    }
8208    if (element.hasCarrierAIDCElement()) {
8209      composeBase64Binary(t, "DeviceUdiCarrierComponent", "carrierAIDC", element.getCarrierAIDCElement(), -1);
8210    }
8211    if (element.hasCarrierHRFElement()) {
8212      composeString(t, "DeviceUdiCarrierComponent", "carrierHRF", element.getCarrierHRFElement(), -1);
8213    }
8214    if (element.hasEntryTypeElement()) {
8215      composeEnum(t, "DeviceUdiCarrierComponent", "entryType", element.getEntryTypeElement(), -1);
8216    }
8217  }
8218
8219  protected void composeDeviceDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceDeviceNameComponent element, int index) {
8220    if (element == null) 
8221      return;
8222    Complex t;
8223    if (Utilities.noString(parentType))
8224      t = parent;
8225    else {
8226      t = parent.predicate("fhir:"+parentType+'.'+name);
8227    }
8228    composeBackboneElement(t, "deviceName", name, element, index);
8229    if (element.hasNameElement()) {
8230      composeString(t, "DeviceDeviceNameComponent", "name", element.getNameElement(), -1);
8231    }
8232    if (element.hasTypeElement()) {
8233      composeEnum(t, "DeviceDeviceNameComponent", "type", element.getTypeElement(), -1);
8234    }
8235  }
8236
8237  protected void composeDeviceSpecializationComponent(Complex parent, String parentType, String name, Device.DeviceSpecializationComponent element, int index) {
8238    if (element == null) 
8239      return;
8240    Complex t;
8241    if (Utilities.noString(parentType))
8242      t = parent;
8243    else {
8244      t = parent.predicate("fhir:"+parentType+'.'+name);
8245    }
8246    composeBackboneElement(t, "specialization", name, element, index);
8247    if (element.hasSystemType()) {
8248      composeCodeableConcept(t, "DeviceSpecializationComponent", "systemType", element.getSystemType(), -1);
8249    }
8250    if (element.hasVersionElement()) {
8251      composeString(t, "DeviceSpecializationComponent", "version", element.getVersionElement(), -1);
8252    }
8253  }
8254
8255  protected void composeDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent element, int index) {
8256    if (element == null) 
8257      return;
8258    Complex t;
8259    if (Utilities.noString(parentType))
8260      t = parent;
8261    else {
8262      t = parent.predicate("fhir:"+parentType+'.'+name);
8263    }
8264    composeBackboneElement(t, "version", name, element, index);
8265    if (element.hasType()) {
8266      composeCodeableConcept(t, "DeviceVersionComponent", "type", element.getType(), -1);
8267    }
8268    if (element.hasComponent()) {
8269      composeIdentifier(t, "DeviceVersionComponent", "component", element.getComponent(), -1);
8270    }
8271    if (element.hasValueElement()) {
8272      composeString(t, "DeviceVersionComponent", "value", element.getValueElement(), -1);
8273    }
8274  }
8275
8276  protected void composeDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent element, int index) {
8277    if (element == null) 
8278      return;
8279    Complex t;
8280    if (Utilities.noString(parentType))
8281      t = parent;
8282    else {
8283      t = parent.predicate("fhir:"+parentType+'.'+name);
8284    }
8285    composeBackboneElement(t, "property", name, element, index);
8286    if (element.hasType()) {
8287      composeCodeableConcept(t, "DevicePropertyComponent", "type", element.getType(), -1);
8288    }
8289    for (int i = 0; i < element.getValueQuantity().size(); i++) {
8290      composeQuantity(t, "DevicePropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i);
8291    }
8292    for (int i = 0; i < element.getValueCode().size(); i++) {
8293      composeCodeableConcept(t, "DevicePropertyComponent", "valueCode", element.getValueCode().get(i), i);
8294    }
8295  }
8296
8297  protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition element, int index) {
8298    if (element == null) 
8299      return;
8300    Complex t;
8301    if (Utilities.noString(parentType))
8302      t = parent;
8303    else {
8304      t = parent.predicate("fhir:"+parentType+'.'+name);
8305    }
8306    composeDomainResource(t, "DeviceDefinition", name, element, index);
8307    for (int i = 0; i < element.getIdentifier().size(); i++) {
8308      composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i);
8309    }
8310    for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) {
8311      composeDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i);
8312    }
8313    if (element.hasManufacturer()) {
8314      composeType(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1);
8315    }
8316    for (int i = 0; i < element.getDeviceName().size(); i++) {
8317      composeDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i);
8318    }
8319    if (element.hasModelNumberElement()) {
8320      composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1);
8321    }
8322    if (element.hasType()) {
8323      composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1);
8324    }
8325    for (int i = 0; i < element.getSpecialization().size(); i++) {
8326      composeDeviceDefinitionSpecializationComponent(t, "DeviceDefinition", "specialization", element.getSpecialization().get(i), i);
8327    }
8328    for (int i = 0; i < element.getVersion().size(); i++) {
8329      composeString(t, "DeviceDefinition", "version", element.getVersion().get(i), i);
8330    }
8331    for (int i = 0; i < element.getSafety().size(); i++) {
8332      composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i);
8333    }
8334    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
8335      composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
8336    }
8337    if (element.hasPhysicalCharacteristics()) {
8338      composeProdCharacteristic(t, "DeviceDefinition", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1);
8339    }
8340    for (int i = 0; i < element.getLanguageCode().size(); i++) {
8341      composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i);
8342    }
8343    for (int i = 0; i < element.getCapability().size(); i++) {
8344      composeDeviceDefinitionCapabilityComponent(t, "DeviceDefinition", "capability", element.getCapability().get(i), i);
8345    }
8346    for (int i = 0; i < element.getProperty().size(); i++) {
8347      composeDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i);
8348    }
8349    if (element.hasOwner()) {
8350      composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1);
8351    }
8352    for (int i = 0; i < element.getContact().size(); i++) {
8353      composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i);
8354    }
8355    if (element.hasUrlElement()) {
8356      composeUri(t, "DeviceDefinition", "url", element.getUrlElement(), -1);
8357    }
8358    if (element.hasOnlineInformationElement()) {
8359      composeUri(t, "DeviceDefinition", "onlineInformation", element.getOnlineInformationElement(), -1);
8360    }
8361    for (int i = 0; i < element.getNote().size(); i++) {
8362      composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i);
8363    }
8364    if (element.hasQuantity()) {
8365      composeQuantity(t, "DeviceDefinition", "quantity", element.getQuantity(), -1);
8366    }
8367    if (element.hasParentDevice()) {
8368      composeReference(t, "DeviceDefinition", "parentDevice", element.getParentDevice(), -1);
8369    }
8370    for (int i = 0; i < element.getMaterial().size(); i++) {
8371      composeDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i);
8372    }
8373  }
8374
8375  protected void composeDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent element, int index) {
8376    if (element == null) 
8377      return;
8378    Complex t;
8379    if (Utilities.noString(parentType))
8380      t = parent;
8381    else {
8382      t = parent.predicate("fhir:"+parentType+'.'+name);
8383    }
8384    composeBackboneElement(t, "udiDeviceIdentifier", name, element, index);
8385    if (element.hasDeviceIdentifierElement()) {
8386      composeString(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
8387    }
8388    if (element.hasIssuerElement()) {
8389      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "issuer", element.getIssuerElement(), -1);
8390    }
8391    if (element.hasJurisdictionElement()) {
8392      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
8393    }
8394  }
8395
8396  protected void composeDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent element, int index) {
8397    if (element == null) 
8398      return;
8399    Complex t;
8400    if (Utilities.noString(parentType))
8401      t = parent;
8402    else {
8403      t = parent.predicate("fhir:"+parentType+'.'+name);
8404    }
8405    composeBackboneElement(t, "deviceName", name, element, index);
8406    if (element.hasNameElement()) {
8407      composeString(t, "DeviceDefinitionDeviceNameComponent", "name", element.getNameElement(), -1);
8408    }
8409    if (element.hasTypeElement()) {
8410      composeEnum(t, "DeviceDefinitionDeviceNameComponent", "type", element.getTypeElement(), -1);
8411    }
8412  }
8413
8414  protected void composeDeviceDefinitionSpecializationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionSpecializationComponent element, int index) {
8415    if (element == null) 
8416      return;
8417    Complex t;
8418    if (Utilities.noString(parentType))
8419      t = parent;
8420    else {
8421      t = parent.predicate("fhir:"+parentType+'.'+name);
8422    }
8423    composeBackboneElement(t, "specialization", name, element, index);
8424    if (element.hasSystemTypeElement()) {
8425      composeString(t, "DeviceDefinitionSpecializationComponent", "systemType", element.getSystemTypeElement(), -1);
8426    }
8427    if (element.hasVersionElement()) {
8428      composeString(t, "DeviceDefinitionSpecializationComponent", "version", element.getVersionElement(), -1);
8429    }
8430  }
8431
8432  protected void composeDeviceDefinitionCapabilityComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCapabilityComponent element, int index) {
8433    if (element == null) 
8434      return;
8435    Complex t;
8436    if (Utilities.noString(parentType))
8437      t = parent;
8438    else {
8439      t = parent.predicate("fhir:"+parentType+'.'+name);
8440    }
8441    composeBackboneElement(t, "capability", name, element, index);
8442    if (element.hasType()) {
8443      composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "type", element.getType(), -1);
8444    }
8445    for (int i = 0; i < element.getDescription().size(); i++) {
8446      composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "description", element.getDescription().get(i), i);
8447    }
8448  }
8449
8450  protected void composeDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent element, int index) {
8451    if (element == null) 
8452      return;
8453    Complex t;
8454    if (Utilities.noString(parentType))
8455      t = parent;
8456    else {
8457      t = parent.predicate("fhir:"+parentType+'.'+name);
8458    }
8459    composeBackboneElement(t, "property", name, element, index);
8460    if (element.hasType()) {
8461      composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "type", element.getType(), -1);
8462    }
8463    for (int i = 0; i < element.getValueQuantity().size(); i++) {
8464      composeQuantity(t, "DeviceDefinitionPropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i);
8465    }
8466    for (int i = 0; i < element.getValueCode().size(); i++) {
8467      composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "valueCode", element.getValueCode().get(i), i);
8468    }
8469  }
8470
8471  protected void composeDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent element, int index) {
8472    if (element == null) 
8473      return;
8474    Complex t;
8475    if (Utilities.noString(parentType))
8476      t = parent;
8477    else {
8478      t = parent.predicate("fhir:"+parentType+'.'+name);
8479    }
8480    composeBackboneElement(t, "material", name, element, index);
8481    if (element.hasSubstance()) {
8482      composeCodeableConcept(t, "DeviceDefinitionMaterialComponent", "substance", element.getSubstance(), -1);
8483    }
8484    if (element.hasAlternateElement()) {
8485      composeBoolean(t, "DeviceDefinitionMaterialComponent", "alternate", element.getAlternateElement(), -1);
8486    }
8487    if (element.hasAllergenicIndicatorElement()) {
8488      composeBoolean(t, "DeviceDefinitionMaterialComponent", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
8489    }
8490  }
8491
8492  protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) {
8493    if (element == null) 
8494      return;
8495    Complex t;
8496    if (Utilities.noString(parentType))
8497      t = parent;
8498    else {
8499      t = parent.predicate("fhir:"+parentType+'.'+name);
8500    }
8501    composeDomainResource(t, "DeviceMetric", name, element, index);
8502    for (int i = 0; i < element.getIdentifier().size(); i++) {
8503      composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i);
8504    }
8505    if (element.hasType()) {
8506      composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1);
8507    }
8508    if (element.hasUnit()) {
8509      composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1);
8510    }
8511    if (element.hasSource()) {
8512      composeReference(t, "DeviceMetric", "source", element.getSource(), -1);
8513    }
8514    if (element.hasParent()) {
8515      composeReference(t, "DeviceMetric", "parent", element.getParent(), -1);
8516    }
8517    if (element.hasOperationalStatusElement()) {
8518      composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1);
8519    }
8520    if (element.hasColorElement()) {
8521      composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1);
8522    }
8523    if (element.hasCategoryElement()) {
8524      composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1);
8525    }
8526    if (element.hasMeasurementPeriod()) {
8527      composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1);
8528    }
8529    for (int i = 0; i < element.getCalibration().size(); i++) {
8530      composeDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i);
8531    }
8532  }
8533
8534  protected void composeDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) {
8535    if (element == null) 
8536      return;
8537    Complex t;
8538    if (Utilities.noString(parentType))
8539      t = parent;
8540    else {
8541      t = parent.predicate("fhir:"+parentType+'.'+name);
8542    }
8543    composeBackboneElement(t, "calibration", name, element, index);
8544    if (element.hasTypeElement()) {
8545      composeEnum(t, "DeviceMetricCalibrationComponent", "type", element.getTypeElement(), -1);
8546    }
8547    if (element.hasStateElement()) {
8548      composeEnum(t, "DeviceMetricCalibrationComponent", "state", element.getStateElement(), -1);
8549    }
8550    if (element.hasTimeElement()) {
8551      composeInstant(t, "DeviceMetricCalibrationComponent", "time", element.getTimeElement(), -1);
8552    }
8553  }
8554
8555  protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) {
8556    if (element == null) 
8557      return;
8558    Complex t;
8559    if (Utilities.noString(parentType))
8560      t = parent;
8561    else {
8562      t = parent.predicate("fhir:"+parentType+'.'+name);
8563    }
8564    composeDomainResource(t, "DeviceRequest", name, element, index);
8565    for (int i = 0; i < element.getIdentifier().size(); i++) {
8566      composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i);
8567    }
8568    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
8569      composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
8570    }
8571    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
8572      composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
8573    }
8574    for (int i = 0; i < element.getBasedOn().size(); i++) {
8575      composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i);
8576    }
8577    for (int i = 0; i < element.getPriorRequest().size(); i++) {
8578      composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i);
8579    }
8580    if (element.hasGroupIdentifier()) {
8581      composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
8582    }
8583    if (element.hasStatusElement()) {
8584      composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1);
8585    }
8586    if (element.hasIntentElement()) {
8587      composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1);
8588    }
8589    if (element.hasPriorityElement()) {
8590      composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1);
8591    }
8592    if (element.hasCode()) {
8593      composeType(t, "DeviceRequest", "code", element.getCode(), -1);
8594    }
8595    for (int i = 0; i < element.getParameter().size(); i++) {
8596      composeDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i);
8597    }
8598    if (element.hasSubject()) {
8599      composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1);
8600    }
8601    if (element.hasEncounter()) {
8602      composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1);
8603    }
8604    if (element.hasOccurrence()) {
8605      composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1);
8606    }
8607    if (element.hasAuthoredOnElement()) {
8608      composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
8609    }
8610    if (element.hasRequester()) {
8611      composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1);
8612    }
8613    if (element.hasPerformerType()) {
8614      composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1);
8615    }
8616    if (element.hasPerformer()) {
8617      composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1);
8618    }
8619    for (int i = 0; i < element.getReasonCode().size(); i++) {
8620      composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i);
8621    }
8622    for (int i = 0; i < element.getReasonReference().size(); i++) {
8623      composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i);
8624    }
8625    for (int i = 0; i < element.getInsurance().size(); i++) {
8626      composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i);
8627    }
8628    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
8629      composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
8630    }
8631    for (int i = 0; i < element.getNote().size(); i++) {
8632      composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i);
8633    }
8634    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
8635      composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
8636    }
8637  }
8638
8639  protected void composeDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent element, int index) {
8640    if (element == null) 
8641      return;
8642    Complex t;
8643    if (Utilities.noString(parentType))
8644      t = parent;
8645    else {
8646      t = parent.predicate("fhir:"+parentType+'.'+name);
8647    }
8648    composeBackboneElement(t, "parameter", name, element, index);
8649    if (element.hasCode()) {
8650      composeCodeableConcept(t, "DeviceRequestParameterComponent", "code", element.getCode(), -1);
8651    }
8652    if (element.hasValue()) {
8653      composeType(t, "DeviceRequestParameterComponent", "value", element.getValue(), -1);
8654    }
8655  }
8656
8657  protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) {
8658    if (element == null) 
8659      return;
8660    Complex t;
8661    if (Utilities.noString(parentType))
8662      t = parent;
8663    else {
8664      t = parent.predicate("fhir:"+parentType+'.'+name);
8665    }
8666    composeDomainResource(t, "DeviceUseStatement", name, element, index);
8667    for (int i = 0; i < element.getIdentifier().size(); i++) {
8668      composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i);
8669    }
8670    for (int i = 0; i < element.getBasedOn().size(); i++) {
8671      composeReference(t, "DeviceUseStatement", "basedOn", element.getBasedOn().get(i), i);
8672    }
8673    if (element.hasStatusElement()) {
8674      composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1);
8675    }
8676    if (element.hasSubject()) {
8677      composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1);
8678    }
8679    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
8680      composeReference(t, "DeviceUseStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
8681    }
8682    if (element.hasTiming()) {
8683      composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1);
8684    }
8685    if (element.hasRecordedOnElement()) {
8686      composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1);
8687    }
8688    if (element.hasSource()) {
8689      composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1);
8690    }
8691    if (element.hasDevice()) {
8692      composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1);
8693    }
8694    for (int i = 0; i < element.getReasonCode().size(); i++) {
8695      composeCodeableConcept(t, "DeviceUseStatement", "reasonCode", element.getReasonCode().get(i), i);
8696    }
8697    for (int i = 0; i < element.getReasonReference().size(); i++) {
8698      composeReference(t, "DeviceUseStatement", "reasonReference", element.getReasonReference().get(i), i);
8699    }
8700    if (element.hasBodySite()) {
8701      composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1);
8702    }
8703    for (int i = 0; i < element.getNote().size(); i++) {
8704      composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i);
8705    }
8706  }
8707
8708  protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) {
8709    if (element == null) 
8710      return;
8711    Complex t;
8712    if (Utilities.noString(parentType))
8713      t = parent;
8714    else {
8715      t = parent.predicate("fhir:"+parentType+'.'+name);
8716    }
8717    composeDomainResource(t, "DiagnosticReport", name, element, index);
8718    for (int i = 0; i < element.getIdentifier().size(); i++) {
8719      composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i);
8720    }
8721    for (int i = 0; i < element.getBasedOn().size(); i++) {
8722      composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i);
8723    }
8724    if (element.hasStatusElement()) {
8725      composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1);
8726    }
8727    for (int i = 0; i < element.getCategory().size(); i++) {
8728      composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i);
8729    }
8730    if (element.hasCode()) {
8731      composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1);
8732    }
8733    if (element.hasSubject()) {
8734      composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1);
8735    }
8736    if (element.hasEncounter()) {
8737      composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1);
8738    }
8739    if (element.hasEffective()) {
8740      composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1);
8741    }
8742    if (element.hasIssuedElement()) {
8743      composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1);
8744    }
8745    for (int i = 0; i < element.getPerformer().size(); i++) {
8746      composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i);
8747    }
8748    for (int i = 0; i < element.getResultsInterpreter().size(); i++) {
8749      composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i);
8750    }
8751    for (int i = 0; i < element.getSpecimen().size(); i++) {
8752      composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i);
8753    }
8754    for (int i = 0; i < element.getResult().size(); i++) {
8755      composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i);
8756    }
8757    for (int i = 0; i < element.getImagingStudy().size(); i++) {
8758      composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i);
8759    }
8760    for (int i = 0; i < element.getMedia().size(); i++) {
8761      composeDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i);
8762    }
8763    if (element.hasConclusionElement()) {
8764      composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1);
8765    }
8766    for (int i = 0; i < element.getConclusionCode().size(); i++) {
8767      composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i);
8768    }
8769    for (int i = 0; i < element.getPresentedForm().size(); i++) {
8770      composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i);
8771    }
8772  }
8773
8774  protected void composeDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent element, int index) {
8775    if (element == null) 
8776      return;
8777    Complex t;
8778    if (Utilities.noString(parentType))
8779      t = parent;
8780    else {
8781      t = parent.predicate("fhir:"+parentType+'.'+name);
8782    }
8783    composeBackboneElement(t, "media", name, element, index);
8784    if (element.hasCommentElement()) {
8785      composeString(t, "DiagnosticReportMediaComponent", "comment", element.getCommentElement(), -1);
8786    }
8787    if (element.hasLink()) {
8788      composeReference(t, "DiagnosticReportMediaComponent", "link", element.getLink(), -1);
8789    }
8790  }
8791
8792  protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) {
8793    if (element == null) 
8794      return;
8795    Complex t;
8796    if (Utilities.noString(parentType))
8797      t = parent;
8798    else {
8799      t = parent.predicate("fhir:"+parentType+'.'+name);
8800    }
8801    composeDomainResource(t, "DocumentManifest", name, element, index);
8802    if (element.hasMasterIdentifier()) {
8803      composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1);
8804    }
8805    for (int i = 0; i < element.getIdentifier().size(); i++) {
8806      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i);
8807    }
8808    if (element.hasStatusElement()) {
8809      composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1);
8810    }
8811    if (element.hasType()) {
8812      composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1);
8813    }
8814    if (element.hasSubject()) {
8815      composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1);
8816    }
8817    if (element.hasCreatedElement()) {
8818      composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1);
8819    }
8820    for (int i = 0; i < element.getAuthor().size(); i++) {
8821      composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i);
8822    }
8823    for (int i = 0; i < element.getRecipient().size(); i++) {
8824      composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i);
8825    }
8826    if (element.hasSourceElement()) {
8827      composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1);
8828    }
8829    if (element.hasDescriptionElement()) {
8830      composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1);
8831    }
8832    for (int i = 0; i < element.getContent().size(); i++) {
8833      composeReference(t, "DocumentManifest", "content", element.getContent().get(i), i);
8834    }
8835    for (int i = 0; i < element.getRelated().size(); i++) {
8836      composeDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i);
8837    }
8838  }
8839
8840  protected void composeDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) {
8841    if (element == null) 
8842      return;
8843    Complex t;
8844    if (Utilities.noString(parentType))
8845      t = parent;
8846    else {
8847      t = parent.predicate("fhir:"+parentType+'.'+name);
8848    }
8849    composeBackboneElement(t, "related", name, element, index);
8850    if (element.hasIdentifier()) {
8851      composeIdentifier(t, "DocumentManifestRelatedComponent", "identifier", element.getIdentifier(), -1);
8852    }
8853    if (element.hasRef()) {
8854      composeReference(t, "DocumentManifestRelatedComponent", "ref", element.getRef(), -1);
8855    }
8856  }
8857
8858  protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) {
8859    if (element == null) 
8860      return;
8861    Complex t;
8862    if (Utilities.noString(parentType))
8863      t = parent;
8864    else {
8865      t = parent.predicate("fhir:"+parentType+'.'+name);
8866    }
8867    composeDomainResource(t, "DocumentReference", name, element, index);
8868    if (element.hasMasterIdentifier()) {
8869      composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1);
8870    }
8871    for (int i = 0; i < element.getIdentifier().size(); i++) {
8872      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i);
8873    }
8874    if (element.hasStatusElement()) {
8875      composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1);
8876    }
8877    if (element.hasDocStatusElement()) {
8878      composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1);
8879    }
8880    if (element.hasType()) {
8881      composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1);
8882    }
8883    for (int i = 0; i < element.getCategory().size(); i++) {
8884      composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i);
8885    }
8886    if (element.hasSubject()) {
8887      composeReference(t, "DocumentReference", "subject", element.getSubject(), -1);
8888    }
8889    if (element.hasDateElement()) {
8890      composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1);
8891    }
8892    for (int i = 0; i < element.getAuthor().size(); i++) {
8893      composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i);
8894    }
8895    if (element.hasAuthenticator()) {
8896      composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1);
8897    }
8898    if (element.hasCustodian()) {
8899      composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1);
8900    }
8901    for (int i = 0; i < element.getRelatesTo().size(); i++) {
8902      composeDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i);
8903    }
8904    if (element.hasDescriptionElement()) {
8905      composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1);
8906    }
8907    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
8908      composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i);
8909    }
8910    for (int i = 0; i < element.getContent().size(); i++) {
8911      composeDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i);
8912    }
8913    if (element.hasContext()) {
8914      composeDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1);
8915    }
8916  }
8917
8918  protected void composeDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) {
8919    if (element == null) 
8920      return;
8921    Complex t;
8922    if (Utilities.noString(parentType))
8923      t = parent;
8924    else {
8925      t = parent.predicate("fhir:"+parentType+'.'+name);
8926    }
8927    composeBackboneElement(t, "relatesTo", name, element, index);
8928    if (element.hasCodeElement()) {
8929      composeEnum(t, "DocumentReferenceRelatesToComponent", "code", element.getCodeElement(), -1);
8930    }
8931    if (element.hasTarget()) {
8932      composeReference(t, "DocumentReferenceRelatesToComponent", "target", element.getTarget(), -1);
8933    }
8934  }
8935
8936  protected void composeDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) {
8937    if (element == null) 
8938      return;
8939    Complex t;
8940    if (Utilities.noString(parentType))
8941      t = parent;
8942    else {
8943      t = parent.predicate("fhir:"+parentType+'.'+name);
8944    }
8945    composeBackboneElement(t, "content", name, element, index);
8946    if (element.hasAttachment()) {
8947      composeAttachment(t, "DocumentReferenceContentComponent", "attachment", element.getAttachment(), -1);
8948    }
8949    if (element.hasFormat()) {
8950      composeCoding(t, "DocumentReferenceContentComponent", "format", element.getFormat(), -1);
8951    }
8952  }
8953
8954  protected void composeDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) {
8955    if (element == null) 
8956      return;
8957    Complex t;
8958    if (Utilities.noString(parentType))
8959      t = parent;
8960    else {
8961      t = parent.predicate("fhir:"+parentType+'.'+name);
8962    }
8963    composeBackboneElement(t, "context", name, element, index);
8964    for (int i = 0; i < element.getEncounter().size(); i++) {
8965      composeReference(t, "DocumentReferenceContextComponent", "encounter", element.getEncounter().get(i), i);
8966    }
8967    for (int i = 0; i < element.getEvent().size(); i++) {
8968      composeCodeableConcept(t, "DocumentReferenceContextComponent", "event", element.getEvent().get(i), i);
8969    }
8970    if (element.hasPeriod()) {
8971      composePeriod(t, "DocumentReferenceContextComponent", "period", element.getPeriod(), -1);
8972    }
8973    if (element.hasFacilityType()) {
8974      composeCodeableConcept(t, "DocumentReferenceContextComponent", "facilityType", element.getFacilityType(), -1);
8975    }
8976    if (element.hasPracticeSetting()) {
8977      composeCodeableConcept(t, "DocumentReferenceContextComponent", "practiceSetting", element.getPracticeSetting(), -1);
8978    }
8979    if (element.hasSourcePatientInfo()) {
8980      composeReference(t, "DocumentReferenceContextComponent", "sourcePatientInfo", element.getSourcePatientInfo(), -1);
8981    }
8982    for (int i = 0; i < element.getRelated().size(); i++) {
8983      composeReference(t, "DocumentReferenceContextComponent", "related", element.getRelated().get(i), i);
8984    }
8985  }
8986
8987  protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) {
8988    if (element == null) 
8989      return;
8990    Complex t;
8991    if (Utilities.noString(parentType))
8992      t = parent;
8993    else {
8994      t = parent.predicate("fhir:"+parentType+'.'+name);
8995    }
8996    composeDomainResource(t, "Encounter", name, element, index);
8997    for (int i = 0; i < element.getIdentifier().size(); i++) {
8998      composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i);
8999    }
9000    if (element.hasStatusElement()) {
9001      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
9002    }
9003    for (int i = 0; i < element.getStatusHistory().size(); i++) {
9004      composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i);
9005    }
9006    if (element.hasClass_()) {
9007      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
9008    }
9009    for (int i = 0; i < element.getClassHistory().size(); i++) {
9010      composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i);
9011    }
9012    for (int i = 0; i < element.getType().size(); i++) {
9013      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
9014    }
9015    if (element.hasServiceType()) {
9016      composeCodeableConcept(t, "Encounter", "serviceType", element.getServiceType(), -1);
9017    }
9018    if (element.hasPriority()) {
9019      composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1);
9020    }
9021    if (element.hasSubject()) {
9022      composeReference(t, "Encounter", "subject", element.getSubject(), -1);
9023    }
9024    for (int i = 0; i < element.getEpisodeOfCare().size(); i++) {
9025      composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i);
9026    }
9027    for (int i = 0; i < element.getBasedOn().size(); i++) {
9028      composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i);
9029    }
9030    for (int i = 0; i < element.getParticipant().size(); i++) {
9031      composeEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i);
9032    }
9033    for (int i = 0; i < element.getAppointment().size(); i++) {
9034      composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i);
9035    }
9036    if (element.hasPeriod()) {
9037      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
9038    }
9039    if (element.hasLength()) {
9040      composeDuration(t, "Encounter", "length", element.getLength(), -1);
9041    }
9042    for (int i = 0; i < element.getReasonCode().size(); i++) {
9043      composeCodeableConcept(t, "Encounter", "reasonCode", element.getReasonCode().get(i), i);
9044    }
9045    for (int i = 0; i < element.getReasonReference().size(); i++) {
9046      composeReference(t, "Encounter", "reasonReference", element.getReasonReference().get(i), i);
9047    }
9048    for (int i = 0; i < element.getDiagnosis().size(); i++) {
9049      composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i);
9050    }
9051    for (int i = 0; i < element.getAccount().size(); i++) {
9052      composeReference(t, "Encounter", "account", element.getAccount().get(i), i);
9053    }
9054    if (element.hasHospitalization()) {
9055      composeEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1);
9056    }
9057    for (int i = 0; i < element.getLocation().size(); i++) {
9058      composeEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i);
9059    }
9060    if (element.hasServiceProvider()) {
9061      composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1);
9062    }
9063    if (element.hasPartOf()) {
9064      composeReference(t, "Encounter", "partOf", element.getPartOf(), -1);
9065    }
9066  }
9067
9068  protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) {
9069    if (element == null) 
9070      return;
9071    Complex t;
9072    if (Utilities.noString(parentType))
9073      t = parent;
9074    else {
9075      t = parent.predicate("fhir:"+parentType+'.'+name);
9076    }
9077    composeBackboneElement(t, "statusHistory", name, element, index);
9078    if (element.hasStatusElement()) {
9079      composeEnum(t, "StatusHistoryComponent", "status", element.getStatusElement(), -1);
9080    }
9081    if (element.hasPeriod()) {
9082      composePeriod(t, "StatusHistoryComponent", "period", element.getPeriod(), -1);
9083    }
9084  }
9085
9086  protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) {
9087    if (element == null) 
9088      return;
9089    Complex t;
9090    if (Utilities.noString(parentType))
9091      t = parent;
9092    else {
9093      t = parent.predicate("fhir:"+parentType+'.'+name);
9094    }
9095    composeBackboneElement(t, "classHistory", name, element, index);
9096    if (element.hasClass_()) {
9097      composeCoding(t, "ClassHistoryComponent", "class", element.getClass_(), -1);
9098    }
9099    if (element.hasPeriod()) {
9100      composePeriod(t, "ClassHistoryComponent", "period", element.getPeriod(), -1);
9101    }
9102  }
9103
9104  protected void composeEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) {
9105    if (element == null) 
9106      return;
9107    Complex t;
9108    if (Utilities.noString(parentType))
9109      t = parent;
9110    else {
9111      t = parent.predicate("fhir:"+parentType+'.'+name);
9112    }
9113    composeBackboneElement(t, "participant", name, element, index);
9114    for (int i = 0; i < element.getType().size(); i++) {
9115      composeCodeableConcept(t, "EncounterParticipantComponent", "type", element.getType().get(i), i);
9116    }
9117    if (element.hasPeriod()) {
9118      composePeriod(t, "EncounterParticipantComponent", "period", element.getPeriod(), -1);
9119    }
9120    if (element.hasIndividual()) {
9121      composeReference(t, "EncounterParticipantComponent", "individual", element.getIndividual(), -1);
9122    }
9123  }
9124
9125  protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) {
9126    if (element == null) 
9127      return;
9128    Complex t;
9129    if (Utilities.noString(parentType))
9130      t = parent;
9131    else {
9132      t = parent.predicate("fhir:"+parentType+'.'+name);
9133    }
9134    composeBackboneElement(t, "diagnosis", name, element, index);
9135    if (element.hasCondition()) {
9136      composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1);
9137    }
9138    if (element.hasUse()) {
9139      composeCodeableConcept(t, "DiagnosisComponent", "use", element.getUse(), -1);
9140    }
9141    if (element.hasRankElement()) {
9142      composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1);
9143    }
9144  }
9145
9146  protected void composeEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) {
9147    if (element == null) 
9148      return;
9149    Complex t;
9150    if (Utilities.noString(parentType))
9151      t = parent;
9152    else {
9153      t = parent.predicate("fhir:"+parentType+'.'+name);
9154    }
9155    composeBackboneElement(t, "hospitalization", name, element, index);
9156    if (element.hasPreAdmissionIdentifier()) {
9157      composeIdentifier(t, "EncounterHospitalizationComponent", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1);
9158    }
9159    if (element.hasOrigin()) {
9160      composeReference(t, "EncounterHospitalizationComponent", "origin", element.getOrigin(), -1);
9161    }
9162    if (element.hasAdmitSource()) {
9163      composeCodeableConcept(t, "EncounterHospitalizationComponent", "admitSource", element.getAdmitSource(), -1);
9164    }
9165    if (element.hasReAdmission()) {
9166      composeCodeableConcept(t, "EncounterHospitalizationComponent", "reAdmission", element.getReAdmission(), -1);
9167    }
9168    for (int i = 0; i < element.getDietPreference().size(); i++) {
9169      composeCodeableConcept(t, "EncounterHospitalizationComponent", "dietPreference", element.getDietPreference().get(i), i);
9170    }
9171    for (int i = 0; i < element.getSpecialCourtesy().size(); i++) {
9172      composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialCourtesy", element.getSpecialCourtesy().get(i), i);
9173    }
9174    for (int i = 0; i < element.getSpecialArrangement().size(); i++) {
9175      composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialArrangement", element.getSpecialArrangement().get(i), i);
9176    }
9177    if (element.hasDestination()) {
9178      composeReference(t, "EncounterHospitalizationComponent", "destination", element.getDestination(), -1);
9179    }
9180    if (element.hasDischargeDisposition()) {
9181      composeCodeableConcept(t, "EncounterHospitalizationComponent", "dischargeDisposition", element.getDischargeDisposition(), -1);
9182    }
9183  }
9184
9185  protected void composeEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) {
9186    if (element == null) 
9187      return;
9188    Complex t;
9189    if (Utilities.noString(parentType))
9190      t = parent;
9191    else {
9192      t = parent.predicate("fhir:"+parentType+'.'+name);
9193    }
9194    composeBackboneElement(t, "location", name, element, index);
9195    if (element.hasLocation()) {
9196      composeReference(t, "EncounterLocationComponent", "location", element.getLocation(), -1);
9197    }
9198    if (element.hasStatusElement()) {
9199      composeEnum(t, "EncounterLocationComponent", "status", element.getStatusElement(), -1);
9200    }
9201    if (element.hasPhysicalType()) {
9202      composeCodeableConcept(t, "EncounterLocationComponent", "physicalType", element.getPhysicalType(), -1);
9203    }
9204    if (element.hasPeriod()) {
9205      composePeriod(t, "EncounterLocationComponent", "period", element.getPeriod(), -1);
9206    }
9207  }
9208
9209  protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) {
9210    if (element == null) 
9211      return;
9212    Complex t;
9213    if (Utilities.noString(parentType))
9214      t = parent;
9215    else {
9216      t = parent.predicate("fhir:"+parentType+'.'+name);
9217    }
9218    composeDomainResource(t, "Endpoint", name, element, index);
9219    for (int i = 0; i < element.getIdentifier().size(); i++) {
9220      composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i);
9221    }
9222    if (element.hasStatusElement()) {
9223      composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1);
9224    }
9225    if (element.hasConnectionType()) {
9226      composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1);
9227    }
9228    if (element.hasNameElement()) {
9229      composeString(t, "Endpoint", "name", element.getNameElement(), -1);
9230    }
9231    if (element.hasManagingOrganization()) {
9232      composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1);
9233    }
9234    for (int i = 0; i < element.getContact().size(); i++) {
9235      composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i);
9236    }
9237    if (element.hasPeriod()) {
9238      composePeriod(t, "Endpoint", "period", element.getPeriod(), -1);
9239    }
9240    for (int i = 0; i < element.getPayloadType().size(); i++) {
9241      composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i);
9242    }
9243    for (int i = 0; i < element.getPayloadMimeType().size(); i++) {
9244      composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i);
9245    }
9246    if (element.hasAddressElement()) {
9247      composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1);
9248    }
9249    for (int i = 0; i < element.getHeader().size(); i++) {
9250      composeString(t, "Endpoint", "header", element.getHeader().get(i), i);
9251    }
9252  }
9253
9254  protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) {
9255    if (element == null) 
9256      return;
9257    Complex t;
9258    if (Utilities.noString(parentType))
9259      t = parent;
9260    else {
9261      t = parent.predicate("fhir:"+parentType+'.'+name);
9262    }
9263    composeDomainResource(t, "EnrollmentRequest", name, element, index);
9264    for (int i = 0; i < element.getIdentifier().size(); i++) {
9265      composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i);
9266    }
9267    if (element.hasStatusElement()) {
9268      composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1);
9269    }
9270    if (element.hasCreatedElement()) {
9271      composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1);
9272    }
9273    if (element.hasInsurer()) {
9274      composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1);
9275    }
9276    if (element.hasProvider()) {
9277      composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1);
9278    }
9279    if (element.hasCandidate()) {
9280      composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1);
9281    }
9282    if (element.hasCoverage()) {
9283      composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1);
9284    }
9285  }
9286
9287  protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) {
9288    if (element == null) 
9289      return;
9290    Complex t;
9291    if (Utilities.noString(parentType))
9292      t = parent;
9293    else {
9294      t = parent.predicate("fhir:"+parentType+'.'+name);
9295    }
9296    composeDomainResource(t, "EnrollmentResponse", name, element, index);
9297    for (int i = 0; i < element.getIdentifier().size(); i++) {
9298      composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i);
9299    }
9300    if (element.hasStatusElement()) {
9301      composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1);
9302    }
9303    if (element.hasRequest()) {
9304      composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1);
9305    }
9306    if (element.hasOutcomeElement()) {
9307      composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1);
9308    }
9309    if (element.hasDispositionElement()) {
9310      composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1);
9311    }
9312    if (element.hasCreatedElement()) {
9313      composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1);
9314    }
9315    if (element.hasOrganization()) {
9316      composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1);
9317    }
9318    if (element.hasRequestProvider()) {
9319      composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1);
9320    }
9321  }
9322
9323  protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) {
9324    if (element == null) 
9325      return;
9326    Complex t;
9327    if (Utilities.noString(parentType))
9328      t = parent;
9329    else {
9330      t = parent.predicate("fhir:"+parentType+'.'+name);
9331    }
9332    composeDomainResource(t, "EpisodeOfCare", name, element, index);
9333    for (int i = 0; i < element.getIdentifier().size(); i++) {
9334      composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i);
9335    }
9336    if (element.hasStatusElement()) {
9337      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
9338    }
9339    for (int i = 0; i < element.getStatusHistory().size(); i++) {
9340      composeEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i);
9341    }
9342    for (int i = 0; i < element.getType().size(); i++) {
9343      composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i);
9344    }
9345    for (int i = 0; i < element.getDiagnosis().size(); i++) {
9346      composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i);
9347    }
9348    if (element.hasPatient()) {
9349      composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1);
9350    }
9351    if (element.hasManagingOrganization()) {
9352      composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1);
9353    }
9354    if (element.hasPeriod()) {
9355      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
9356    }
9357    for (int i = 0; i < element.getReferralRequest().size(); i++) {
9358      composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i);
9359    }
9360    if (element.hasCareManager()) {
9361      composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1);
9362    }
9363    for (int i = 0; i < element.getTeam().size(); i++) {
9364      composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i);
9365    }
9366    for (int i = 0; i < element.getAccount().size(); i++) {
9367      composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i);
9368    }
9369  }
9370
9371  protected void composeEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) {
9372    if (element == null) 
9373      return;
9374    Complex t;
9375    if (Utilities.noString(parentType))
9376      t = parent;
9377    else {
9378      t = parent.predicate("fhir:"+parentType+'.'+name);
9379    }
9380    composeBackboneElement(t, "statusHistory", name, element, index);
9381    if (element.hasStatusElement()) {
9382      composeEnum(t, "EpisodeOfCareStatusHistoryComponent", "status", element.getStatusElement(), -1);
9383    }
9384    if (element.hasPeriod()) {
9385      composePeriod(t, "EpisodeOfCareStatusHistoryComponent", "period", element.getPeriod(), -1);
9386    }
9387  }
9388
9389  protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) {
9390    if (element == null) 
9391      return;
9392    Complex t;
9393    if (Utilities.noString(parentType))
9394      t = parent;
9395    else {
9396      t = parent.predicate("fhir:"+parentType+'.'+name);
9397    }
9398    composeBackboneElement(t, "diagnosis", name, element, index);
9399    if (element.hasCondition()) {
9400      composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1);
9401    }
9402    if (element.hasRole()) {
9403      composeCodeableConcept(t, "DiagnosisComponent", "role", element.getRole(), -1);
9404    }
9405    if (element.hasRankElement()) {
9406      composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1);
9407    }
9408  }
9409
9410  protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition element, int index) {
9411    if (element == null) 
9412      return;
9413    Complex t;
9414    if (Utilities.noString(parentType))
9415      t = parent;
9416    else {
9417      t = parent.predicate("fhir:"+parentType+'.'+name);
9418    }
9419    composeDomainResource(t, "EventDefinition", name, element, index);
9420    if (element.hasUrlElement()) {
9421      composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1);
9422    }
9423    for (int i = 0; i < element.getIdentifier().size(); i++) {
9424      composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i);
9425    }
9426    if (element.hasVersionElement()) {
9427      composeString(t, "EventDefinition", "version", element.getVersionElement(), -1);
9428    }
9429    if (element.hasNameElement()) {
9430      composeString(t, "EventDefinition", "name", element.getNameElement(), -1);
9431    }
9432    if (element.hasTitleElement()) {
9433      composeString(t, "EventDefinition", "title", element.getTitleElement(), -1);
9434    }
9435    if (element.hasSubtitleElement()) {
9436      composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1);
9437    }
9438    if (element.hasStatusElement()) {
9439      composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1);
9440    }
9441    if (element.hasExperimentalElement()) {
9442      composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1);
9443    }
9444    if (element.hasSubject()) {
9445      composeType(t, "EventDefinition", "subject", element.getSubject(), -1);
9446    }
9447    if (element.hasDateElement()) {
9448      composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1);
9449    }
9450    if (element.hasPublisherElement()) {
9451      composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1);
9452    }
9453    for (int i = 0; i < element.getContact().size(); i++) {
9454      composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i);
9455    }
9456    if (element.hasDescriptionElement()) {
9457      composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1);
9458    }
9459    for (int i = 0; i < element.getUseContext().size(); i++) {
9460      composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i);
9461    }
9462    for (int i = 0; i < element.getJurisdiction().size(); i++) {
9463      composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
9464    }
9465    if (element.hasPurposeElement()) {
9466      composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1);
9467    }
9468    if (element.hasUsageElement()) {
9469      composeString(t, "EventDefinition", "usage", element.getUsageElement(), -1);
9470    }
9471    if (element.hasCopyrightElement()) {
9472      composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1);
9473    }
9474    if (element.hasApprovalDateElement()) {
9475      composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1);
9476    }
9477    if (element.hasLastReviewDateElement()) {
9478      composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
9479    }
9480    if (element.hasEffectivePeriod()) {
9481      composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
9482    }
9483    for (int i = 0; i < element.getTopic().size(); i++) {
9484      composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i);
9485    }
9486    for (int i = 0; i < element.getAuthor().size(); i++) {
9487      composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i);
9488    }
9489    for (int i = 0; i < element.getEditor().size(); i++) {
9490      composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i);
9491    }
9492    for (int i = 0; i < element.getReviewer().size(); i++) {
9493      composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i);
9494    }
9495    for (int i = 0; i < element.getEndorser().size(); i++) {
9496      composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i);
9497    }
9498    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9499      composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9500    }
9501    for (int i = 0; i < element.getTrigger().size(); i++) {
9502      composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i);
9503    }
9504  }
9505
9506  protected void composeEvidence(Complex parent, String parentType, String name, Evidence element, int index) {
9507    if (element == null) 
9508      return;
9509    Complex t;
9510    if (Utilities.noString(parentType))
9511      t = parent;
9512    else {
9513      t = parent.predicate("fhir:"+parentType+'.'+name);
9514    }
9515    composeDomainResource(t, "Evidence", name, element, index);
9516    if (element.hasUrlElement()) {
9517      composeUri(t, "Evidence", "url", element.getUrlElement(), -1);
9518    }
9519    for (int i = 0; i < element.getIdentifier().size(); i++) {
9520      composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i);
9521    }
9522    if (element.hasVersionElement()) {
9523      composeString(t, "Evidence", "version", element.getVersionElement(), -1);
9524    }
9525    if (element.hasTitleElement()) {
9526      composeString(t, "Evidence", "title", element.getTitleElement(), -1);
9527    }
9528    if (element.hasCiteAs()) {
9529      composeType(t, "Evidence", "citeAs", element.getCiteAs(), -1);
9530    }
9531    if (element.hasStatusElement()) {
9532      composeEnum(t, "Evidence", "status", element.getStatusElement(), -1);
9533    }
9534    if (element.hasDateElement()) {
9535      composeDateTime(t, "Evidence", "date", element.getDateElement(), -1);
9536    }
9537    for (int i = 0; i < element.getUseContext().size(); i++) {
9538      composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i);
9539    }
9540    if (element.hasApprovalDateElement()) {
9541      composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1);
9542    }
9543    if (element.hasLastReviewDateElement()) {
9544      composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1);
9545    }
9546    if (element.hasPublisherElement()) {
9547      composeString(t, "Evidence", "publisher", element.getPublisherElement(), -1);
9548    }
9549    for (int i = 0; i < element.getContact().size(); i++) {
9550      composeContactDetail(t, "Evidence", "contact", element.getContact().get(i), i);
9551    }
9552    for (int i = 0; i < element.getAuthor().size(); i++) {
9553      composeContactDetail(t, "Evidence", "author", element.getAuthor().get(i), i);
9554    }
9555    for (int i = 0; i < element.getEditor().size(); i++) {
9556      composeContactDetail(t, "Evidence", "editor", element.getEditor().get(i), i);
9557    }
9558    for (int i = 0; i < element.getReviewer().size(); i++) {
9559      composeContactDetail(t, "Evidence", "reviewer", element.getReviewer().get(i), i);
9560    }
9561    for (int i = 0; i < element.getEndorser().size(); i++) {
9562      composeContactDetail(t, "Evidence", "endorser", element.getEndorser().get(i), i);
9563    }
9564    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9565      composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9566    }
9567    if (element.hasDescriptionElement()) {
9568      composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1);
9569    }
9570    if (element.hasAssertionElement()) {
9571      composeMarkdown(t, "Evidence", "assertion", element.getAssertionElement(), -1);
9572    }
9573    for (int i = 0; i < element.getNote().size(); i++) {
9574      composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i);
9575    }
9576    for (int i = 0; i < element.getVariableDefinition().size(); i++) {
9577      composeEvidenceVariableDefinitionComponent(t, "Evidence", "variableDefinition", element.getVariableDefinition().get(i), i);
9578    }
9579    if (element.hasSynthesisType()) {
9580      composeCodeableConcept(t, "Evidence", "synthesisType", element.getSynthesisType(), -1);
9581    }
9582    if (element.hasStudyType()) {
9583      composeCodeableConcept(t, "Evidence", "studyType", element.getStudyType(), -1);
9584    }
9585    for (int i = 0; i < element.getStatistic().size(); i++) {
9586      composeEvidenceStatisticComponent(t, "Evidence", "statistic", element.getStatistic().get(i), i);
9587    }
9588    for (int i = 0; i < element.getCertainty().size(); i++) {
9589      composeEvidenceCertaintyComponent(t, "Evidence", "certainty", element.getCertainty().get(i), i);
9590    }
9591  }
9592
9593  protected void composeEvidenceVariableDefinitionComponent(Complex parent, String parentType, String name, Evidence.EvidenceVariableDefinitionComponent element, int index) {
9594    if (element == null) 
9595      return;
9596    Complex t;
9597    if (Utilities.noString(parentType))
9598      t = parent;
9599    else {
9600      t = parent.predicate("fhir:"+parentType+'.'+name);
9601    }
9602    composeBackboneElement(t, "variableDefinition", name, element, index);
9603    if (element.hasDescriptionElement()) {
9604      composeMarkdown(t, "EvidenceVariableDefinitionComponent", "description", element.getDescriptionElement(), -1);
9605    }
9606    for (int i = 0; i < element.getNote().size(); i++) {
9607      composeAnnotation(t, "EvidenceVariableDefinitionComponent", "note", element.getNote().get(i), i);
9608    }
9609    if (element.hasVariableRole()) {
9610      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "variableRole", element.getVariableRole(), -1);
9611    }
9612    if (element.hasObserved()) {
9613      composeReference(t, "EvidenceVariableDefinitionComponent", "observed", element.getObserved(), -1);
9614    }
9615    if (element.hasIntended()) {
9616      composeReference(t, "EvidenceVariableDefinitionComponent", "intended", element.getIntended(), -1);
9617    }
9618    if (element.hasDirectnessMatch()) {
9619      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "directnessMatch", element.getDirectnessMatch(), -1);
9620    }
9621  }
9622
9623  protected void composeEvidenceStatisticComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticComponent element, int index) {
9624    if (element == null) 
9625      return;
9626    Complex t;
9627    if (Utilities.noString(parentType))
9628      t = parent;
9629    else {
9630      t = parent.predicate("fhir:"+parentType+'.'+name);
9631    }
9632    composeBackboneElement(t, "statistic", name, element, index);
9633    if (element.hasDescriptionElement()) {
9634      composeString(t, "EvidenceStatisticComponent", "description", element.getDescriptionElement(), -1);
9635    }
9636    for (int i = 0; i < element.getNote().size(); i++) {
9637      composeAnnotation(t, "EvidenceStatisticComponent", "note", element.getNote().get(i), i);
9638    }
9639    if (element.hasStatisticType()) {
9640      composeCodeableConcept(t, "EvidenceStatisticComponent", "statisticType", element.getStatisticType(), -1);
9641    }
9642    if (element.hasCategory()) {
9643      composeCodeableConcept(t, "EvidenceStatisticComponent", "category", element.getCategory(), -1);
9644    }
9645    if (element.hasQuantity()) {
9646      composeQuantity(t, "EvidenceStatisticComponent", "quantity", element.getQuantity(), -1);
9647    }
9648    if (element.hasNumberOfEventsElement()) {
9649      composeUnsignedInt(t, "EvidenceStatisticComponent", "numberOfEvents", element.getNumberOfEventsElement(), -1);
9650    }
9651    if (element.hasNumberAffectedElement()) {
9652      composeUnsignedInt(t, "EvidenceStatisticComponent", "numberAffected", element.getNumberAffectedElement(), -1);
9653    }
9654    if (element.hasSampleSize()) {
9655      composeEvidenceStatisticSampleSizeComponent(t, "EvidenceStatisticComponent", "sampleSize", element.getSampleSize(), -1);
9656    }
9657    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
9658      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
9659    }
9660    for (int i = 0; i < element.getModelCharacteristic().size(); i++) {
9661      composeEvidenceStatisticModelCharacteristicComponent(t, "EvidenceStatisticComponent", "modelCharacteristic", element.getModelCharacteristic().get(i), i);
9662    }
9663  }
9664
9665  protected void composeEvidenceStatisticSampleSizeComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticSampleSizeComponent element, int index) {
9666    if (element == null) 
9667      return;
9668    Complex t;
9669    if (Utilities.noString(parentType))
9670      t = parent;
9671    else {
9672      t = parent.predicate("fhir:"+parentType+'.'+name);
9673    }
9674    composeBackboneElement(t, "sampleSize", name, element, index);
9675    if (element.hasDescriptionElement()) {
9676      composeString(t, "EvidenceStatisticSampleSizeComponent", "description", element.getDescriptionElement(), -1);
9677    }
9678    for (int i = 0; i < element.getNote().size(); i++) {
9679      composeAnnotation(t, "EvidenceStatisticSampleSizeComponent", "note", element.getNote().get(i), i);
9680    }
9681    if (element.hasNumberOfStudiesElement()) {
9682      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "numberOfStudies", element.getNumberOfStudiesElement(), -1);
9683    }
9684    if (element.hasNumberOfParticipantsElement()) {
9685      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1);
9686    }
9687    if (element.hasKnownDataCountElement()) {
9688      composeUnsignedInt(t, "EvidenceStatisticSampleSizeComponent", "knownDataCount", element.getKnownDataCountElement(), -1);
9689    }
9690  }
9691
9692  protected void composeEvidenceStatisticAttributeEstimateComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticAttributeEstimateComponent element, int index) {
9693    if (element == null) 
9694      return;
9695    Complex t;
9696    if (Utilities.noString(parentType))
9697      t = parent;
9698    else {
9699      t = parent.predicate("fhir:"+parentType+'.'+name);
9700    }
9701    composeBackboneElement(t, "attributeEstimate", name, element, index);
9702    if (element.hasDescriptionElement()) {
9703      composeString(t, "EvidenceStatisticAttributeEstimateComponent", "description", element.getDescriptionElement(), -1);
9704    }
9705    for (int i = 0; i < element.getNote().size(); i++) {
9706      composeAnnotation(t, "EvidenceStatisticAttributeEstimateComponent", "note", element.getNote().get(i), i);
9707    }
9708    if (element.hasType()) {
9709      composeCodeableConcept(t, "EvidenceStatisticAttributeEstimateComponent", "type", element.getType(), -1);
9710    }
9711    if (element.hasQuantity()) {
9712      composeQuantity(t, "EvidenceStatisticAttributeEstimateComponent", "quantity", element.getQuantity(), -1);
9713    }
9714    if (element.hasLevelElement()) {
9715      composeDecimal(t, "EvidenceStatisticAttributeEstimateComponent", "level", element.getLevelElement(), -1);
9716    }
9717    if (element.hasRange()) {
9718      composeRange(t, "EvidenceStatisticAttributeEstimateComponent", "range", element.getRange(), -1);
9719    }
9720    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
9721      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticAttributeEstimateComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
9722    }
9723  }
9724
9725  protected void composeEvidenceStatisticModelCharacteristicComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticModelCharacteristicComponent element, int index) {
9726    if (element == null) 
9727      return;
9728    Complex t;
9729    if (Utilities.noString(parentType))
9730      t = parent;
9731    else {
9732      t = parent.predicate("fhir:"+parentType+'.'+name);
9733    }
9734    composeBackboneElement(t, "modelCharacteristic", name, element, index);
9735    if (element.hasCode()) {
9736      composeCodeableConcept(t, "EvidenceStatisticModelCharacteristicComponent", "code", element.getCode(), -1);
9737    }
9738    if (element.hasValue()) {
9739      composeQuantity(t, "EvidenceStatisticModelCharacteristicComponent", "value", element.getValue(), -1);
9740    }
9741    for (int i = 0; i < element.getVariable().size(); i++) {
9742      composeEvidenceStatisticModelCharacteristicVariableComponent(t, "EvidenceStatisticModelCharacteristicComponent", "variable", element.getVariable().get(i), i);
9743    }
9744    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
9745      composeEvidenceStatisticAttributeEstimateComponent(t, "EvidenceStatisticModelCharacteristicComponent", "attributeEstimate", element.getAttributeEstimate().get(i), i);
9746    }
9747  }
9748
9749  protected void composeEvidenceStatisticModelCharacteristicVariableComponent(Complex parent, String parentType, String name, Evidence.EvidenceStatisticModelCharacteristicVariableComponent element, int index) {
9750    if (element == null) 
9751      return;
9752    Complex t;
9753    if (Utilities.noString(parentType))
9754      t = parent;
9755    else {
9756      t = parent.predicate("fhir:"+parentType+'.'+name);
9757    }
9758    composeBackboneElement(t, "variable", name, element, index);
9759    if (element.hasVariableDefinition()) {
9760      composeReference(t, "EvidenceStatisticModelCharacteristicVariableComponent", "variableDefinition", element.getVariableDefinition(), -1);
9761    }
9762    if (element.hasHandlingElement()) {
9763      composeEnum(t, "EvidenceStatisticModelCharacteristicVariableComponent", "handling", element.getHandlingElement(), -1);
9764    }
9765    for (int i = 0; i < element.getValueCategory().size(); i++) {
9766      composeCodeableConcept(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueCategory", element.getValueCategory().get(i), i);
9767    }
9768    for (int i = 0; i < element.getValueQuantity().size(); i++) {
9769      composeQuantity(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueQuantity", element.getValueQuantity().get(i), i);
9770    }
9771    for (int i = 0; i < element.getValueRange().size(); i++) {
9772      composeRange(t, "EvidenceStatisticModelCharacteristicVariableComponent", "valueRange", element.getValueRange().get(i), i);
9773    }
9774  }
9775
9776  protected void composeEvidenceCertaintyComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyComponent element, int index) {
9777    if (element == null) 
9778      return;
9779    Complex t;
9780    if (Utilities.noString(parentType))
9781      t = parent;
9782    else {
9783      t = parent.predicate("fhir:"+parentType+'.'+name);
9784    }
9785    composeBackboneElement(t, "certainty", name, element, index);
9786    if (element.hasDescriptionElement()) {
9787      composeString(t, "EvidenceCertaintyComponent", "description", element.getDescriptionElement(), -1);
9788    }
9789    for (int i = 0; i < element.getNote().size(); i++) {
9790      composeAnnotation(t, "EvidenceCertaintyComponent", "note", element.getNote().get(i), i);
9791    }
9792    if (element.hasType()) {
9793      composeCodeableConcept(t, "EvidenceCertaintyComponent", "type", element.getType(), -1);
9794    }
9795    if (element.hasRating()) {
9796      composeCodeableConcept(t, "EvidenceCertaintyComponent", "rating", element.getRating(), -1);
9797    }
9798    if (element.hasRaterElement()) {
9799      composeString(t, "EvidenceCertaintyComponent", "rater", element.getRaterElement(), -1);
9800    }
9801    for (int i = 0; i < element.getSubcomponent().size(); i++) {
9802      composeEvidenceCertaintyComponent(t, "EvidenceCertaintyComponent", "subcomponent", element.getSubcomponent().get(i), i);
9803    }
9804  }
9805
9806  protected void composeEvidenceReport(Complex parent, String parentType, String name, EvidenceReport element, int index) {
9807    if (element == null) 
9808      return;
9809    Complex t;
9810    if (Utilities.noString(parentType))
9811      t = parent;
9812    else {
9813      t = parent.predicate("fhir:"+parentType+'.'+name);
9814    }
9815    composeDomainResource(t, "EvidenceReport", name, element, index);
9816    if (element.hasUrlElement()) {
9817      composeUri(t, "EvidenceReport", "url", element.getUrlElement(), -1);
9818    }
9819    if (element.hasStatusElement()) {
9820      composeEnum(t, "EvidenceReport", "status", element.getStatusElement(), -1);
9821    }
9822    for (int i = 0; i < element.getUseContext().size(); i++) {
9823      composeUsageContext(t, "EvidenceReport", "useContext", element.getUseContext().get(i), i);
9824    }
9825    for (int i = 0; i < element.getIdentifier().size(); i++) {
9826      composeIdentifier(t, "EvidenceReport", "identifier", element.getIdentifier().get(i), i);
9827    }
9828    for (int i = 0; i < element.getRelatedIdentifier().size(); i++) {
9829      composeIdentifier(t, "EvidenceReport", "relatedIdentifier", element.getRelatedIdentifier().get(i), i);
9830    }
9831    if (element.hasCiteAs()) {
9832      composeType(t, "EvidenceReport", "citeAs", element.getCiteAs(), -1);
9833    }
9834    if (element.hasType()) {
9835      composeCodeableConcept(t, "EvidenceReport", "type", element.getType(), -1);
9836    }
9837    for (int i = 0; i < element.getNote().size(); i++) {
9838      composeAnnotation(t, "EvidenceReport", "note", element.getNote().get(i), i);
9839    }
9840    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9841      composeRelatedArtifact(t, "EvidenceReport", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9842    }
9843    if (element.hasSubject()) {
9844      composeEvidenceReportSubjectComponent(t, "EvidenceReport", "subject", element.getSubject(), -1);
9845    }
9846    if (element.hasPublisherElement()) {
9847      composeString(t, "EvidenceReport", "publisher", element.getPublisherElement(), -1);
9848    }
9849    for (int i = 0; i < element.getContact().size(); i++) {
9850      composeContactDetail(t, "EvidenceReport", "contact", element.getContact().get(i), i);
9851    }
9852    for (int i = 0; i < element.getAuthor().size(); i++) {
9853      composeContactDetail(t, "EvidenceReport", "author", element.getAuthor().get(i), i);
9854    }
9855    for (int i = 0; i < element.getEditor().size(); i++) {
9856      composeContactDetail(t, "EvidenceReport", "editor", element.getEditor().get(i), i);
9857    }
9858    for (int i = 0; i < element.getReviewer().size(); i++) {
9859      composeContactDetail(t, "EvidenceReport", "reviewer", element.getReviewer().get(i), i);
9860    }
9861    for (int i = 0; i < element.getEndorser().size(); i++) {
9862      composeContactDetail(t, "EvidenceReport", "endorser", element.getEndorser().get(i), i);
9863    }
9864    for (int i = 0; i < element.getRelatesTo().size(); i++) {
9865      composeEvidenceReportRelatesToComponent(t, "EvidenceReport", "relatesTo", element.getRelatesTo().get(i), i);
9866    }
9867    for (int i = 0; i < element.getSection().size(); i++) {
9868      composeEvidenceReportSectionComponent(t, "EvidenceReport", "section", element.getSection().get(i), i);
9869    }
9870  }
9871
9872  protected void composeEvidenceReportSubjectComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportSubjectComponent element, int index) {
9873    if (element == null) 
9874      return;
9875    Complex t;
9876    if (Utilities.noString(parentType))
9877      t = parent;
9878    else {
9879      t = parent.predicate("fhir:"+parentType+'.'+name);
9880    }
9881    composeBackboneElement(t, "subject", name, element, index);
9882    for (int i = 0; i < element.getCharacteristic().size(); i++) {
9883      composeEvidenceReportSubjectCharacteristicComponent(t, "EvidenceReportSubjectComponent", "characteristic", element.getCharacteristic().get(i), i);
9884    }
9885    for (int i = 0; i < element.getNote().size(); i++) {
9886      composeAnnotation(t, "EvidenceReportSubjectComponent", "note", element.getNote().get(i), i);
9887    }
9888  }
9889
9890  protected void composeEvidenceReportSubjectCharacteristicComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportSubjectCharacteristicComponent element, int index) {
9891    if (element == null) 
9892      return;
9893    Complex t;
9894    if (Utilities.noString(parentType))
9895      t = parent;
9896    else {
9897      t = parent.predicate("fhir:"+parentType+'.'+name);
9898    }
9899    composeBackboneElement(t, "characteristic", name, element, index);
9900    if (element.hasCode()) {
9901      composeCodeableConcept(t, "EvidenceReportSubjectCharacteristicComponent", "code", element.getCode(), -1);
9902    }
9903    if (element.hasValue()) {
9904      composeType(t, "EvidenceReportSubjectCharacteristicComponent", "value", element.getValue(), -1);
9905    }
9906    if (element.hasExcludeElement()) {
9907      composeBoolean(t, "EvidenceReportSubjectCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
9908    }
9909    if (element.hasPeriod()) {
9910      composePeriod(t, "EvidenceReportSubjectCharacteristicComponent", "period", element.getPeriod(), -1);
9911    }
9912  }
9913
9914  protected void composeEvidenceReportRelatesToComponent(Complex parent, String parentType, String name, EvidenceReport.EvidenceReportRelatesToComponent element, int index) {
9915    if (element == null) 
9916      return;
9917    Complex t;
9918    if (Utilities.noString(parentType))
9919      t = parent;
9920    else {
9921      t = parent.predicate("fhir:"+parentType+'.'+name);
9922    }
9923    composeBackboneElement(t, "relatesTo", name, element, index);
9924    if (element.hasCodeElement()) {
9925      composeEnum(t, "EvidenceReportRelatesToComponent", "code", element.getCodeElement(), -1);
9926    }
9927    if (element.hasTarget()) {
9928      composeType(t, "EvidenceReportRelatesToComponent", "target", element.getTarget(), -1);
9929    }
9930  }
9931
9932  protected void composeEvidenceReportSectionComponent(Complex parent, String parentType, String name, EvidenceReport.SectionComponent element, int index) {
9933    if (element == null) 
9934      return;
9935    Complex t;
9936    if (Utilities.noString(parentType))
9937      t = parent;
9938    else {
9939      t = parent.predicate("fhir:"+parentType+'.'+name);
9940    }
9941    composeBackboneElement(t, "section", name, element, index);
9942    if (element.hasTitleElement()) {
9943      composeString(t, "SectionComponent", "title", element.getTitleElement(), -1);
9944    }
9945    if (element.hasFocus()) {
9946      composeCodeableConcept(t, "SectionComponent", "focus", element.getFocus(), -1);
9947    }
9948    if (element.hasFocusReference()) {
9949      composeReference(t, "SectionComponent", "focusReference", element.getFocusReference(), -1);
9950    }
9951    for (int i = 0; i < element.getAuthor().size(); i++) {
9952      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
9953    }
9954    if (element.hasText()) {
9955      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
9956    }
9957    if (element.hasModeElement()) {
9958      composeEnum(t, "SectionComponent", "mode", element.getModeElement(), -1);
9959    }
9960    if (element.hasOrderedBy()) {
9961      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
9962    }
9963    for (int i = 0; i < element.getEntryClassifier().size(); i++) {
9964      composeCodeableConcept(t, "SectionComponent", "entryClassifier", element.getEntryClassifier().get(i), i);
9965    }
9966    for (int i = 0; i < element.getEntryReference().size(); i++) {
9967      composeReference(t, "SectionComponent", "entryReference", element.getEntryReference().get(i), i);
9968    }
9969    for (int i = 0; i < element.getEntryQuantity().size(); i++) {
9970      composeQuantity(t, "SectionComponent", "entryQuantity", element.getEntryQuantity().get(i), i);
9971    }
9972    if (element.hasEmptyReason()) {
9973      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
9974    }
9975    for (int i = 0; i < element.getSection().size(); i++) {
9976      composeEvidenceReportSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
9977    }
9978  }
9979
9980  protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable element, int index) {
9981    if (element == null) 
9982      return;
9983    Complex t;
9984    if (Utilities.noString(parentType))
9985      t = parent;
9986    else {
9987      t = parent.predicate("fhir:"+parentType+'.'+name);
9988    }
9989    composeDomainResource(t, "EvidenceVariable", name, element, index);
9990    if (element.hasUrlElement()) {
9991      composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1);
9992    }
9993    for (int i = 0; i < element.getIdentifier().size(); i++) {
9994      composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i);
9995    }
9996    if (element.hasVersionElement()) {
9997      composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1);
9998    }
9999    if (element.hasNameElement()) {
10000      composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1);
10001    }
10002    if (element.hasTitleElement()) {
10003      composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1);
10004    }
10005    if (element.hasShortTitleElement()) {
10006      composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1);
10007    }
10008    if (element.hasSubtitleElement()) {
10009      composeString(t, "EvidenceVariable", "subtitle", element.getSubtitleElement(), -1);
10010    }
10011    if (element.hasStatusElement()) {
10012      composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1);
10013    }
10014    if (element.hasDateElement()) {
10015      composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1);
10016    }
10017    if (element.hasDescriptionElement()) {
10018      composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1);
10019    }
10020    for (int i = 0; i < element.getNote().size(); i++) {
10021      composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i);
10022    }
10023    for (int i = 0; i < element.getUseContext().size(); i++) {
10024      composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i);
10025    }
10026    if (element.hasPublisherElement()) {
10027      composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1);
10028    }
10029    for (int i = 0; i < element.getContact().size(); i++) {
10030      composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i);
10031    }
10032    for (int i = 0; i < element.getAuthor().size(); i++) {
10033      composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i);
10034    }
10035    for (int i = 0; i < element.getEditor().size(); i++) {
10036      composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i);
10037    }
10038    for (int i = 0; i < element.getReviewer().size(); i++) {
10039      composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i);
10040    }
10041    for (int i = 0; i < element.getEndorser().size(); i++) {
10042      composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i);
10043    }
10044    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
10045      composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i);
10046    }
10047    if (element.hasActualElement()) {
10048      composeBoolean(t, "EvidenceVariable", "actual", element.getActualElement(), -1);
10049    }
10050    if (element.hasCharacteristicCombinationElement()) {
10051      composeEnum(t, "EvidenceVariable", "characteristicCombination", element.getCharacteristicCombinationElement(), -1);
10052    }
10053    for (int i = 0; i < element.getCharacteristic().size(); i++) {
10054      composeEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i);
10055    }
10056    if (element.hasHandlingElement()) {
10057      composeEnum(t, "EvidenceVariable", "handling", element.getHandlingElement(), -1);
10058    }
10059    for (int i = 0; i < element.getCategory().size(); i++) {
10060      composeEvidenceVariableCategoryComponent(t, "EvidenceVariable", "category", element.getCategory().get(i), i);
10061    }
10062  }
10063
10064  protected void composeEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent element, int index) {
10065    if (element == null) 
10066      return;
10067    Complex t;
10068    if (Utilities.noString(parentType))
10069      t = parent;
10070    else {
10071      t = parent.predicate("fhir:"+parentType+'.'+name);
10072    }
10073    composeBackboneElement(t, "characteristic", name, element, index);
10074    if (element.hasDescriptionElement()) {
10075      composeString(t, "EvidenceVariableCharacteristicComponent", "description", element.getDescriptionElement(), -1);
10076    }
10077    if (element.hasDefinition()) {
10078      composeType(t, "EvidenceVariableCharacteristicComponent", "definition", element.getDefinition(), -1);
10079    }
10080    if (element.hasMethod()) {
10081      composeCodeableConcept(t, "EvidenceVariableCharacteristicComponent", "method", element.getMethod(), -1);
10082    }
10083    if (element.hasDevice()) {
10084      composeReference(t, "EvidenceVariableCharacteristicComponent", "device", element.getDevice(), -1);
10085    }
10086    if (element.hasExcludeElement()) {
10087      composeBoolean(t, "EvidenceVariableCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
10088    }
10089    if (element.hasTimeFromStart()) {
10090      composeEvidenceVariableCharacteristicTimeFromStartComponent(t, "EvidenceVariableCharacteristicComponent", "timeFromStart", element.getTimeFromStart(), -1);
10091    }
10092    if (element.hasGroupMeasureElement()) {
10093      composeEnum(t, "EvidenceVariableCharacteristicComponent", "groupMeasure", element.getGroupMeasureElement(), -1);
10094    }
10095  }
10096
10097  protected void composeEvidenceVariableCharacteristicTimeFromStartComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicTimeFromStartComponent element, int index) {
10098    if (element == null) 
10099      return;
10100    Complex t;
10101    if (Utilities.noString(parentType))
10102      t = parent;
10103    else {
10104      t = parent.predicate("fhir:"+parentType+'.'+name);
10105    }
10106    composeBackboneElement(t, "timeFromStart", name, element, index);
10107    if (element.hasDescriptionElement()) {
10108      composeString(t, "EvidenceVariableCharacteristicTimeFromStartComponent", "description", element.getDescriptionElement(), -1);
10109    }
10110    if (element.hasQuantity()) {
10111      composeQuantity(t, "EvidenceVariableCharacteristicTimeFromStartComponent", "quantity", element.getQuantity(), -1);
10112    }
10113    if (element.hasRange()) {
10114      composeRange(t, "EvidenceVariableCharacteristicTimeFromStartComponent", "range", element.getRange(), -1);
10115    }
10116    for (int i = 0; i < element.getNote().size(); i++) {
10117      composeAnnotation(t, "EvidenceVariableCharacteristicTimeFromStartComponent", "note", element.getNote().get(i), i);
10118    }
10119  }
10120
10121  protected void composeEvidenceVariableCategoryComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCategoryComponent element, int index) {
10122    if (element == null) 
10123      return;
10124    Complex t;
10125    if (Utilities.noString(parentType))
10126      t = parent;
10127    else {
10128      t = parent.predicate("fhir:"+parentType+'.'+name);
10129    }
10130    composeBackboneElement(t, "category", name, element, index);
10131    if (element.hasNameElement()) {
10132      composeString(t, "EvidenceVariableCategoryComponent", "name", element.getNameElement(), -1);
10133    }
10134    if (element.hasValue()) {
10135      composeType(t, "EvidenceVariableCategoryComponent", "value", element.getValue(), -1);
10136    }
10137  }
10138
10139  protected void composeExampleScenario(Complex parent, String parentType, String name, ExampleScenario element, int index) {
10140    if (element == null) 
10141      return;
10142    Complex t;
10143    if (Utilities.noString(parentType))
10144      t = parent;
10145    else {
10146      t = parent.predicate("fhir:"+parentType+'.'+name);
10147    }
10148    composeDomainResource(t, "ExampleScenario", name, element, index);
10149    if (element.hasUrlElement()) {
10150      composeUri(t, "ExampleScenario", "url", element.getUrlElement(), -1);
10151    }
10152    for (int i = 0; i < element.getIdentifier().size(); i++) {
10153      composeIdentifier(t, "ExampleScenario", "identifier", element.getIdentifier().get(i), i);
10154    }
10155    if (element.hasVersionElement()) {
10156      composeString(t, "ExampleScenario", "version", element.getVersionElement(), -1);
10157    }
10158    if (element.hasNameElement()) {
10159      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
10160    }
10161    if (element.hasStatusElement()) {
10162      composeEnum(t, "ExampleScenario", "status", element.getStatusElement(), -1);
10163    }
10164    if (element.hasExperimentalElement()) {
10165      composeBoolean(t, "ExampleScenario", "experimental", element.getExperimentalElement(), -1);
10166    }
10167    if (element.hasDateElement()) {
10168      composeDateTime(t, "ExampleScenario", "date", element.getDateElement(), -1);
10169    }
10170    if (element.hasPublisherElement()) {
10171      composeString(t, "ExampleScenario", "publisher", element.getPublisherElement(), -1);
10172    }
10173    for (int i = 0; i < element.getContact().size(); i++) {
10174      composeContactDetail(t, "ExampleScenario", "contact", element.getContact().get(i), i);
10175    }
10176    for (int i = 0; i < element.getUseContext().size(); i++) {
10177      composeUsageContext(t, "ExampleScenario", "useContext", element.getUseContext().get(i), i);
10178    }
10179    for (int i = 0; i < element.getJurisdiction().size(); i++) {
10180      composeCodeableConcept(t, "ExampleScenario", "jurisdiction", element.getJurisdiction().get(i), i);
10181    }
10182    if (element.hasCopyrightElement()) {
10183      composeMarkdown(t, "ExampleScenario", "copyright", element.getCopyrightElement(), -1);
10184    }
10185    if (element.hasPurposeElement()) {
10186      composeMarkdown(t, "ExampleScenario", "purpose", element.getPurposeElement(), -1);
10187    }
10188    for (int i = 0; i < element.getActor().size(); i++) {
10189      composeExampleScenarioActorComponent(t, "ExampleScenario", "actor", element.getActor().get(i), i);
10190    }
10191    for (int i = 0; i < element.getInstance().size(); i++) {
10192      composeExampleScenarioInstanceComponent(t, "ExampleScenario", "instance", element.getInstance().get(i), i);
10193    }
10194    for (int i = 0; i < element.getProcess().size(); i++) {
10195      composeExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i);
10196    }
10197    for (int i = 0; i < element.getWorkflow().size(); i++) {
10198      composeCanonical(t, "ExampleScenario", "workflow", element.getWorkflow().get(i), i);
10199    }
10200  }
10201
10202  protected void composeExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent element, int index) {
10203    if (element == null) 
10204      return;
10205    Complex t;
10206    if (Utilities.noString(parentType))
10207      t = parent;
10208    else {
10209      t = parent.predicate("fhir:"+parentType+'.'+name);
10210    }
10211    composeBackboneElement(t, "actor", name, element, index);
10212    if (element.hasActorIdElement()) {
10213      composeString(t, "ExampleScenarioActorComponent", "actorId", element.getActorIdElement(), -1);
10214    }
10215    if (element.hasTypeElement()) {
10216      composeEnum(t, "ExampleScenarioActorComponent", "type", element.getTypeElement(), -1);
10217    }
10218    if (element.hasNameElement()) {
10219      composeString(t, "ExampleScenarioActorComponent", "name", element.getNameElement(), -1);
10220    }
10221    if (element.hasDescriptionElement()) {
10222      composeMarkdown(t, "ExampleScenarioActorComponent", "description", element.getDescriptionElement(), -1);
10223    }
10224  }
10225
10226  protected void composeExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent element, int index) {
10227    if (element == null) 
10228      return;
10229    Complex t;
10230    if (Utilities.noString(parentType))
10231      t = parent;
10232    else {
10233      t = parent.predicate("fhir:"+parentType+'.'+name);
10234    }
10235    composeBackboneElement(t, "instance", name, element, index);
10236    if (element.hasResourceIdElement()) {
10237      composeString(t, "ExampleScenarioInstanceComponent", "resourceId", element.getResourceIdElement(), -1);
10238    }
10239    if (element.hasResourceTypeElement()) {
10240      composeCode(t, "ExampleScenarioInstanceComponent", "resourceType", element.getResourceTypeElement(), -1);
10241    }
10242    if (element.hasNameElement()) {
10243      composeString(t, "ExampleScenarioInstanceComponent", "name", element.getNameElement(), -1);
10244    }
10245    if (element.hasDescriptionElement()) {
10246      composeMarkdown(t, "ExampleScenarioInstanceComponent", "description", element.getDescriptionElement(), -1);
10247    }
10248    for (int i = 0; i < element.getVersion().size(); i++) {
10249      composeExampleScenarioInstanceVersionComponent(t, "ExampleScenarioInstanceComponent", "version", element.getVersion().get(i), i);
10250    }
10251    for (int i = 0; i < element.getContainedInstance().size(); i++) {
10252      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioInstanceComponent", "containedInstance", element.getContainedInstance().get(i), i);
10253    }
10254  }
10255
10256  protected void composeExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent element, int index) {
10257    if (element == null) 
10258      return;
10259    Complex t;
10260    if (Utilities.noString(parentType))
10261      t = parent;
10262    else {
10263      t = parent.predicate("fhir:"+parentType+'.'+name);
10264    }
10265    composeBackboneElement(t, "version", name, element, index);
10266    if (element.hasVersionIdElement()) {
10267      composeString(t, "ExampleScenarioInstanceVersionComponent", "versionId", element.getVersionIdElement(), -1);
10268    }
10269    if (element.hasDescriptionElement()) {
10270      composeMarkdown(t, "ExampleScenarioInstanceVersionComponent", "description", element.getDescriptionElement(), -1);
10271    }
10272  }
10273
10274  protected void composeExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent element, int index) {
10275    if (element == null) 
10276      return;
10277    Complex t;
10278    if (Utilities.noString(parentType))
10279      t = parent;
10280    else {
10281      t = parent.predicate("fhir:"+parentType+'.'+name);
10282    }
10283    composeBackboneElement(t, "containedInstance", name, element, index);
10284    if (element.hasResourceIdElement()) {
10285      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "resourceId", element.getResourceIdElement(), -1);
10286    }
10287    if (element.hasVersionIdElement()) {
10288      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "versionId", element.getVersionIdElement(), -1);
10289    }
10290  }
10291
10292  protected void composeExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent element, int index) {
10293    if (element == null) 
10294      return;
10295    Complex t;
10296    if (Utilities.noString(parentType))
10297      t = parent;
10298    else {
10299      t = parent.predicate("fhir:"+parentType+'.'+name);
10300    }
10301    composeBackboneElement(t, "process", name, element, index);
10302    if (element.hasTitleElement()) {
10303      composeString(t, "ExampleScenarioProcessComponent", "title", element.getTitleElement(), -1);
10304    }
10305    if (element.hasDescriptionElement()) {
10306      composeMarkdown(t, "ExampleScenarioProcessComponent", "description", element.getDescriptionElement(), -1);
10307    }
10308    if (element.hasPreConditionsElement()) {
10309      composeMarkdown(t, "ExampleScenarioProcessComponent", "preConditions", element.getPreConditionsElement(), -1);
10310    }
10311    if (element.hasPostConditionsElement()) {
10312      composeMarkdown(t, "ExampleScenarioProcessComponent", "postConditions", element.getPostConditionsElement(), -1);
10313    }
10314    for (int i = 0; i < element.getStep().size(); i++) {
10315      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessComponent", "step", element.getStep().get(i), i);
10316    }
10317  }
10318
10319  protected void composeExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent element, int index) {
10320    if (element == null) 
10321      return;
10322    Complex t;
10323    if (Utilities.noString(parentType))
10324      t = parent;
10325    else {
10326      t = parent.predicate("fhir:"+parentType+'.'+name);
10327    }
10328    composeBackboneElement(t, "step", name, element, index);
10329    for (int i = 0; i < element.getProcess().size(); i++) {
10330      composeExampleScenarioProcessComponent(t, "ExampleScenarioProcessStepComponent", "process", element.getProcess().get(i), i);
10331    }
10332    if (element.hasPauseElement()) {
10333      composeBoolean(t, "ExampleScenarioProcessStepComponent", "pause", element.getPauseElement(), -1);
10334    }
10335    if (element.hasOperation()) {
10336      composeExampleScenarioProcessStepOperationComponent(t, "ExampleScenarioProcessStepComponent", "operation", element.getOperation(), -1);
10337    }
10338    for (int i = 0; i < element.getAlternative().size(); i++) {
10339      composeExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenarioProcessStepComponent", "alternative", element.getAlternative().get(i), i);
10340    }
10341  }
10342
10343  protected void composeExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent element, int index) {
10344    if (element == null) 
10345      return;
10346    Complex t;
10347    if (Utilities.noString(parentType))
10348      t = parent;
10349    else {
10350      t = parent.predicate("fhir:"+parentType+'.'+name);
10351    }
10352    composeBackboneElement(t, "operation", name, element, index);
10353    if (element.hasNumberElement()) {
10354      composeString(t, "ExampleScenarioProcessStepOperationComponent", "number", element.getNumberElement(), -1);
10355    }
10356    if (element.hasTypeElement()) {
10357      composeString(t, "ExampleScenarioProcessStepOperationComponent", "type", element.getTypeElement(), -1);
10358    }
10359    if (element.hasNameElement()) {
10360      composeString(t, "ExampleScenarioProcessStepOperationComponent", "name", element.getNameElement(), -1);
10361    }
10362    if (element.hasInitiatorElement()) {
10363      composeString(t, "ExampleScenarioProcessStepOperationComponent", "initiator", element.getInitiatorElement(), -1);
10364    }
10365    if (element.hasReceiverElement()) {
10366      composeString(t, "ExampleScenarioProcessStepOperationComponent", "receiver", element.getReceiverElement(), -1);
10367    }
10368    if (element.hasDescriptionElement()) {
10369      composeMarkdown(t, "ExampleScenarioProcessStepOperationComponent", "description", element.getDescriptionElement(), -1);
10370    }
10371    if (element.hasInitiatorActiveElement()) {
10372      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "initiatorActive", element.getInitiatorActiveElement(), -1);
10373    }
10374    if (element.hasReceiverActiveElement()) {
10375      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "receiverActive", element.getReceiverActiveElement(), -1);
10376    }
10377    if (element.hasRequest()) {
10378      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "request", element.getRequest(), -1);
10379    }
10380    if (element.hasResponse()) {
10381      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "response", element.getResponse(), -1);
10382    }
10383  }
10384
10385  protected void composeExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent element, int index) {
10386    if (element == null) 
10387      return;
10388    Complex t;
10389    if (Utilities.noString(parentType))
10390      t = parent;
10391    else {
10392      t = parent.predicate("fhir:"+parentType+'.'+name);
10393    }
10394    composeBackboneElement(t, "alternative", name, element, index);
10395    if (element.hasTitleElement()) {
10396      composeString(t, "ExampleScenarioProcessStepAlternativeComponent", "title", element.getTitleElement(), -1);
10397    }
10398    if (element.hasDescriptionElement()) {
10399      composeMarkdown(t, "ExampleScenarioProcessStepAlternativeComponent", "description", element.getDescriptionElement(), -1);
10400    }
10401    for (int i = 0; i < element.getStep().size(); i++) {
10402      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessStepAlternativeComponent", "step", element.getStep().get(i), i);
10403    }
10404  }
10405
10406  protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) {
10407    if (element == null) 
10408      return;
10409    Complex t;
10410    if (Utilities.noString(parentType))
10411      t = parent;
10412    else {
10413      t = parent.predicate("fhir:"+parentType+'.'+name);
10414    }
10415    composeDomainResource(t, "ExplanationOfBenefit", name, element, index);
10416    for (int i = 0; i < element.getIdentifier().size(); i++) {
10417      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i);
10418    }
10419    if (element.hasStatusElement()) {
10420      composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1);
10421    }
10422    if (element.hasType()) {
10423      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
10424    }
10425    if (element.hasSubType()) {
10426      composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1);
10427    }
10428    if (element.hasUseElement()) {
10429      composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1);
10430    }
10431    if (element.hasPatient()) {
10432      composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1);
10433    }
10434    if (element.hasBillablePeriod()) {
10435      composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1);
10436    }
10437    if (element.hasCreatedElement()) {
10438      composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1);
10439    }
10440    if (element.hasEnterer()) {
10441      composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1);
10442    }
10443    if (element.hasInsurer()) {
10444      composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1);
10445    }
10446    if (element.hasProvider()) {
10447      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
10448    }
10449    if (element.hasPriority()) {
10450      composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1);
10451    }
10452    if (element.hasFundsReserveRequested()) {
10453      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1);
10454    }
10455    if (element.hasFundsReserve()) {
10456      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1);
10457    }
10458    for (int i = 0; i < element.getRelated().size(); i++) {
10459      composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i);
10460    }
10461    if (element.hasPrescription()) {
10462      composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1);
10463    }
10464    if (element.hasOriginalPrescription()) {
10465      composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1);
10466    }
10467    if (element.hasPayee()) {
10468      composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1);
10469    }
10470    if (element.hasReferral()) {
10471      composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1);
10472    }
10473    if (element.hasFacility()) {
10474      composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1);
10475    }
10476    if (element.hasClaim()) {
10477      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
10478    }
10479    if (element.hasClaimResponse()) {
10480      composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1);
10481    }
10482    if (element.hasOutcomeElement()) {
10483      composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1);
10484    }
10485    if (element.hasDispositionElement()) {
10486      composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1);
10487    }
10488    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
10489      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
10490    }
10491    for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++) {
10492      composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i);
10493    }
10494    for (int i = 0; i < element.getCareTeam().size(); i++) {
10495      composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i);
10496    }
10497    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
10498      composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i);
10499    }
10500    for (int i = 0; i < element.getDiagnosis().size(); i++) {
10501      composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i);
10502    }
10503    for (int i = 0; i < element.getProcedure().size(); i++) {
10504      composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i);
10505    }
10506    if (element.hasPrecedenceElement()) {
10507      composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1);
10508    }
10509    for (int i = 0; i < element.getInsurance().size(); i++) {
10510      composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i);
10511    }
10512    if (element.hasAccident()) {
10513      composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1);
10514    }
10515    for (int i = 0; i < element.getItem().size(); i++) {
10516      composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i);
10517    }
10518    for (int i = 0; i < element.getAddItem().size(); i++) {
10519      composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i);
10520    }
10521    for (int i = 0; i < element.getAdjudication().size(); i++) {
10522      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
10523    }
10524    for (int i = 0; i < element.getTotal().size(); i++) {
10525      composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i);
10526    }
10527    if (element.hasPayment()) {
10528      composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1);
10529    }
10530    if (element.hasFormCode()) {
10531      composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1);
10532    }
10533    if (element.hasForm()) {
10534      composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1);
10535    }
10536    for (int i = 0; i < element.getProcessNote().size(); i++) {
10537      composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i);
10538    }
10539    if (element.hasBenefitPeriod()) {
10540      composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1);
10541    }
10542    for (int i = 0; i < element.getBenefitBalance().size(); i++) {
10543      composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i);
10544    }
10545  }
10546
10547  protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) {
10548    if (element == null) 
10549      return;
10550    Complex t;
10551    if (Utilities.noString(parentType))
10552      t = parent;
10553    else {
10554      t = parent.predicate("fhir:"+parentType+'.'+name);
10555    }
10556    composeBackboneElement(t, "related", name, element, index);
10557    if (element.hasClaim()) {
10558      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
10559    }
10560    if (element.hasRelationship()) {
10561      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
10562    }
10563    if (element.hasReference()) {
10564      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
10565    }
10566  }
10567
10568  protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) {
10569    if (element == null) 
10570      return;
10571    Complex t;
10572    if (Utilities.noString(parentType))
10573      t = parent;
10574    else {
10575      t = parent.predicate("fhir:"+parentType+'.'+name);
10576    }
10577    composeBackboneElement(t, "payee", name, element, index);
10578    if (element.hasType()) {
10579      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
10580    }
10581    if (element.hasParty()) {
10582      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
10583    }
10584  }
10585
10586  protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) {
10587    if (element == null) 
10588      return;
10589    Complex t;
10590    if (Utilities.noString(parentType))
10591      t = parent;
10592    else {
10593      t = parent.predicate("fhir:"+parentType+'.'+name);
10594    }
10595    composeBackboneElement(t, "careTeam", name, element, index);
10596    if (element.hasSequenceElement()) {
10597      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
10598    }
10599    if (element.hasProvider()) {
10600      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
10601    }
10602    if (element.hasResponsibleElement()) {
10603      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
10604    }
10605    if (element.hasRole()) {
10606      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
10607    }
10608    if (element.hasQualification()) {
10609      composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1);
10610    }
10611  }
10612
10613  protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) {
10614    if (element == null) 
10615      return;
10616    Complex t;
10617    if (Utilities.noString(parentType))
10618      t = parent;
10619    else {
10620      t = parent.predicate("fhir:"+parentType+'.'+name);
10621    }
10622    composeBackboneElement(t, "supportingInfo", name, element, index);
10623    if (element.hasSequenceElement()) {
10624      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
10625    }
10626    if (element.hasCategory()) {
10627      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
10628    }
10629    if (element.hasCode()) {
10630      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
10631    }
10632    if (element.hasTiming()) {
10633      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
10634    }
10635    if (element.hasValue()) {
10636      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
10637    }
10638    if (element.hasReason()) {
10639      composeCoding(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
10640    }
10641  }
10642
10643  protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) {
10644    if (element == null) 
10645      return;
10646    Complex t;
10647    if (Utilities.noString(parentType))
10648      t = parent;
10649    else {
10650      t = parent.predicate("fhir:"+parentType+'.'+name);
10651    }
10652    composeBackboneElement(t, "diagnosis", name, element, index);
10653    if (element.hasSequenceElement()) {
10654      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
10655    }
10656    if (element.hasDiagnosis()) {
10657      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
10658    }
10659    for (int i = 0; i < element.getType().size(); i++) {
10660      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
10661    }
10662    if (element.hasOnAdmission()) {
10663      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
10664    }
10665    if (element.hasPackageCode()) {
10666      composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1);
10667    }
10668  }
10669
10670  protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) {
10671    if (element == null) 
10672      return;
10673    Complex t;
10674    if (Utilities.noString(parentType))
10675      t = parent;
10676    else {
10677      t = parent.predicate("fhir:"+parentType+'.'+name);
10678    }
10679    composeBackboneElement(t, "procedure", name, element, index);
10680    if (element.hasSequenceElement()) {
10681      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
10682    }
10683    for (int i = 0; i < element.getType().size(); i++) {
10684      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
10685    }
10686    if (element.hasDateElement()) {
10687      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
10688    }
10689    if (element.hasProcedure()) {
10690      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
10691    }
10692    for (int i = 0; i < element.getUdi().size(); i++) {
10693      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
10694    }
10695  }
10696
10697  protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) {
10698    if (element == null) 
10699      return;
10700    Complex t;
10701    if (Utilities.noString(parentType))
10702      t = parent;
10703    else {
10704      t = parent.predicate("fhir:"+parentType+'.'+name);
10705    }
10706    composeBackboneElement(t, "insurance", name, element, index);
10707    if (element.hasFocalElement()) {
10708      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
10709    }
10710    if (element.hasCoverage()) {
10711      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
10712    }
10713    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
10714      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
10715    }
10716  }
10717
10718  protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) {
10719    if (element == null) 
10720      return;
10721    Complex t;
10722    if (Utilities.noString(parentType))
10723      t = parent;
10724    else {
10725      t = parent.predicate("fhir:"+parentType+'.'+name);
10726    }
10727    composeBackboneElement(t, "accident", name, element, index);
10728    if (element.hasDateElement()) {
10729      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
10730    }
10731    if (element.hasType()) {
10732      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
10733    }
10734    if (element.hasLocation()) {
10735      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
10736    }
10737  }
10738
10739  protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) {
10740    if (element == null) 
10741      return;
10742    Complex t;
10743    if (Utilities.noString(parentType))
10744      t = parent;
10745    else {
10746      t = parent.predicate("fhir:"+parentType+'.'+name);
10747    }
10748    composeBackboneElement(t, "item", name, element, index);
10749    if (element.hasSequenceElement()) {
10750      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
10751    }
10752    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
10753      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
10754    }
10755    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
10756      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
10757    }
10758    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
10759      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
10760    }
10761    for (int i = 0; i < element.getInformationSequence().size(); i++) {
10762      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
10763    }
10764    if (element.hasRevenue()) {
10765      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
10766    }
10767    if (element.hasCategory()) {
10768      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
10769    }
10770    if (element.hasProductOrService()) {
10771      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
10772    }
10773    for (int i = 0; i < element.getModifier().size(); i++) {
10774      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
10775    }
10776    for (int i = 0; i < element.getProgramCode().size(); i++) {
10777      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
10778    }
10779    if (element.hasServiced()) {
10780      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
10781    }
10782    if (element.hasLocation()) {
10783      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
10784    }
10785    if (element.hasQuantity()) {
10786      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
10787    }
10788    if (element.hasUnitPrice()) {
10789      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
10790    }
10791    if (element.hasFactorElement()) {
10792      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
10793    }
10794    if (element.hasNet()) {
10795      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
10796    }
10797    for (int i = 0; i < element.getUdi().size(); i++) {
10798      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
10799    }
10800    if (element.hasBodySite()) {
10801      composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1);
10802    }
10803    for (int i = 0; i < element.getSubSite().size(); i++) {
10804      composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i);
10805    }
10806    for (int i = 0; i < element.getEncounter().size(); i++) {
10807      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
10808    }
10809    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10810      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
10811    }
10812    for (int i = 0; i < element.getAdjudication().size(); i++) {
10813      composeExplanationOfBenefitAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
10814    }
10815    for (int i = 0; i < element.getDetail().size(); i++) {
10816      composeExplanationOfBenefitDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
10817    }
10818  }
10819
10820  protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) {
10821    if (element == null) 
10822      return;
10823    Complex t;
10824    if (Utilities.noString(parentType))
10825      t = parent;
10826    else {
10827      t = parent.predicate("fhir:"+parentType+'.'+name);
10828    }
10829    composeBackboneElement(t, "adjudication", name, element, index);
10830    if (element.hasCategory()) {
10831      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
10832    }
10833    if (element.hasReason()) {
10834      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
10835    }
10836    if (element.hasAmount()) {
10837      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
10838    }
10839    if (element.hasValueElement()) {
10840      composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1);
10841    }
10842  }
10843
10844  protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) {
10845    if (element == null) 
10846      return;
10847    Complex t;
10848    if (Utilities.noString(parentType))
10849      t = parent;
10850    else {
10851      t = parent.predicate("fhir:"+parentType+'.'+name);
10852    }
10853    composeBackboneElement(t, "detail", name, element, index);
10854    if (element.hasSequenceElement()) {
10855      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
10856    }
10857    if (element.hasRevenue()) {
10858      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
10859    }
10860    if (element.hasCategory()) {
10861      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
10862    }
10863    if (element.hasProductOrService()) {
10864      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
10865    }
10866    for (int i = 0; i < element.getModifier().size(); i++) {
10867      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
10868    }
10869    for (int i = 0; i < element.getProgramCode().size(); i++) {
10870      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
10871    }
10872    if (element.hasQuantity()) {
10873      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
10874    }
10875    if (element.hasUnitPrice()) {
10876      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
10877    }
10878    if (element.hasFactorElement()) {
10879      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
10880    }
10881    if (element.hasNet()) {
10882      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
10883    }
10884    for (int i = 0; i < element.getUdi().size(); i++) {
10885      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
10886    }
10887    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10888      composePositiveInt(t, "DetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10889    }
10890    for (int i = 0; i < element.getAdjudication().size(); i++) {
10891      composeExplanationOfBenefitAdjudicationComponent(t, "DetailComponent", "adjudication", element.getAdjudication().get(i), i);
10892    }
10893    for (int i = 0; i < element.getSubDetail().size(); i++) {
10894      composeExplanationOfBenefitSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
10895    }
10896  }
10897
10898  protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) {
10899    if (element == null) 
10900      return;
10901    Complex t;
10902    if (Utilities.noString(parentType))
10903      t = parent;
10904    else {
10905      t = parent.predicate("fhir:"+parentType+'.'+name);
10906    }
10907    composeBackboneElement(t, "subDetail", name, element, index);
10908    if (element.hasSequenceElement()) {
10909      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
10910    }
10911    if (element.hasRevenue()) {
10912      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
10913    }
10914    if (element.hasCategory()) {
10915      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
10916    }
10917    if (element.hasProductOrService()) {
10918      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
10919    }
10920    for (int i = 0; i < element.getModifier().size(); i++) {
10921      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
10922    }
10923    for (int i = 0; i < element.getProgramCode().size(); i++) {
10924      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
10925    }
10926    if (element.hasQuantity()) {
10927      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
10928    }
10929    if (element.hasUnitPrice()) {
10930      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
10931    }
10932    if (element.hasFactorElement()) {
10933      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
10934    }
10935    if (element.hasNet()) {
10936      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
10937    }
10938    for (int i = 0; i < element.getUdi().size(); i++) {
10939      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
10940    }
10941    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10942      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10943    }
10944    for (int i = 0; i < element.getAdjudication().size(); i++) {
10945      composeExplanationOfBenefitAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
10946    }
10947  }
10948
10949  protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) {
10950    if (element == null) 
10951      return;
10952    Complex t;
10953    if (Utilities.noString(parentType))
10954      t = parent;
10955    else {
10956      t = parent.predicate("fhir:"+parentType+'.'+name);
10957    }
10958    composeBackboneElement(t, "addItem", name, element, index);
10959    for (int i = 0; i < element.getItemSequence().size(); i++) {
10960      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
10961    }
10962    for (int i = 0; i < element.getDetailSequence().size(); i++) {
10963      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
10964    }
10965    for (int i = 0; i < element.getSubDetailSequence().size(); i++) {
10966      composePositiveInt(t, "AddedItemComponent", "subDetailSequence", element.getSubDetailSequence().get(i), i);
10967    }
10968    for (int i = 0; i < element.getProvider().size(); i++) {
10969      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
10970    }
10971    if (element.hasProductOrService()) {
10972      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
10973    }
10974    for (int i = 0; i < element.getModifier().size(); i++) {
10975      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
10976    }
10977    for (int i = 0; i < element.getProgramCode().size(); i++) {
10978      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
10979    }
10980    if (element.hasServiced()) {
10981      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
10982    }
10983    if (element.hasLocation()) {
10984      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
10985    }
10986    if (element.hasQuantity()) {
10987      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
10988    }
10989    if (element.hasUnitPrice()) {
10990      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
10991    }
10992    if (element.hasFactorElement()) {
10993      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
10994    }
10995    if (element.hasNet()) {
10996      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
10997    }
10998    if (element.hasBodySite()) {
10999      composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1);
11000    }
11001    for (int i = 0; i < element.getSubSite().size(); i++) {
11002      composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i);
11003    }
11004    for (int i = 0; i < element.getNoteNumber().size(); i++) {
11005      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
11006    }
11007    for (int i = 0; i < element.getAdjudication().size(); i++) {
11008      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
11009    }
11010    for (int i = 0; i < element.getDetail().size(); i++) {
11011      composeExplanationOfBenefitAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
11012    }
11013  }
11014
11015  protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailComponent element, int index) {
11016    if (element == null) 
11017      return;
11018    Complex t;
11019    if (Utilities.noString(parentType))
11020      t = parent;
11021    else {
11022      t = parent.predicate("fhir:"+parentType+'.'+name);
11023    }
11024    composeBackboneElement(t, "detail", name, element, index);
11025    if (element.hasProductOrService()) {
11026      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
11027    }
11028    for (int i = 0; i < element.getModifier().size(); i++) {
11029      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
11030    }
11031    if (element.hasQuantity()) {
11032      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
11033    }
11034    if (element.hasUnitPrice()) {
11035      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
11036    }
11037    if (element.hasFactorElement()) {
11038      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
11039    }
11040    if (element.hasNet()) {
11041      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
11042    }
11043    for (int i = 0; i < element.getNoteNumber().size(); i++) {
11044      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
11045    }
11046    for (int i = 0; i < element.getAdjudication().size(); i++) {
11047      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
11048    }
11049    for (int i = 0; i < element.getSubDetail().size(); i++) {
11050      composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
11051    }
11052  }
11053
11054  protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent element, int index) {
11055    if (element == null) 
11056      return;
11057    Complex t;
11058    if (Utilities.noString(parentType))
11059      t = parent;
11060    else {
11061      t = parent.predicate("fhir:"+parentType+'.'+name);
11062    }
11063    composeBackboneElement(t, "subDetail", name, element, index);
11064    if (element.hasProductOrService()) {
11065      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "productOrService", element.getProductOrService(), -1);
11066    }
11067    for (int i = 0; i < element.getModifier().size(); i++) {
11068      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "modifier", element.getModifier().get(i), i);
11069    }
11070    if (element.hasQuantity()) {
11071      composeQuantity(t, "AddedItemDetailSubDetailComponent", "quantity", element.getQuantity(), -1);
11072    }
11073    if (element.hasUnitPrice()) {
11074      composeMoney(t, "AddedItemDetailSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
11075    }
11076    if (element.hasFactorElement()) {
11077      composeDecimal(t, "AddedItemDetailSubDetailComponent", "factor", element.getFactorElement(), -1);
11078    }
11079    if (element.hasNet()) {
11080      composeMoney(t, "AddedItemDetailSubDetailComponent", "net", element.getNet(), -1);
11081    }
11082    for (int i = 0; i < element.getNoteNumber().size(); i++) {
11083      composePositiveInt(t, "AddedItemDetailSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
11084    }
11085    for (int i = 0; i < element.getAdjudication().size(); i++) {
11086      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
11087    }
11088  }
11089
11090  protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.TotalComponent element, int index) {
11091    if (element == null) 
11092      return;
11093    Complex t;
11094    if (Utilities.noString(parentType))
11095      t = parent;
11096    else {
11097      t = parent.predicate("fhir:"+parentType+'.'+name);
11098    }
11099    composeBackboneElement(t, "total", name, element, index);
11100    if (element.hasCategory()) {
11101      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
11102    }
11103    if (element.hasAmount()) {
11104      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
11105    }
11106  }
11107
11108  protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) {
11109    if (element == null) 
11110      return;
11111    Complex t;
11112    if (Utilities.noString(parentType))
11113      t = parent;
11114    else {
11115      t = parent.predicate("fhir:"+parentType+'.'+name);
11116    }
11117    composeBackboneElement(t, "payment", name, element, index);
11118    if (element.hasType()) {
11119      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
11120    }
11121    if (element.hasAdjustment()) {
11122      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
11123    }
11124    if (element.hasAdjustmentReason()) {
11125      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
11126    }
11127    if (element.hasDateElement()) {
11128      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
11129    }
11130    if (element.hasAmount()) {
11131      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
11132    }
11133    if (element.hasIdentifier()) {
11134      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
11135    }
11136  }
11137
11138  protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) {
11139    if (element == null) 
11140      return;
11141    Complex t;
11142    if (Utilities.noString(parentType))
11143      t = parent;
11144    else {
11145      t = parent.predicate("fhir:"+parentType+'.'+name);
11146    }
11147    composeBackboneElement(t, "processNote", name, element, index);
11148    if (element.hasNumberElement()) {
11149      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
11150    }
11151    if (element.hasTypeElement()) {
11152      composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1);
11153    }
11154    if (element.hasTextElement()) {
11155      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
11156    }
11157    if (element.hasLanguage()) {
11158      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
11159    }
11160  }
11161
11162  protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) {
11163    if (element == null) 
11164      return;
11165    Complex t;
11166    if (Utilities.noString(parentType))
11167      t = parent;
11168    else {
11169      t = parent.predicate("fhir:"+parentType+'.'+name);
11170    }
11171    composeBackboneElement(t, "benefitBalance", name, element, index);
11172    if (element.hasCategory()) {
11173      composeCodeableConcept(t, "BenefitBalanceComponent", "category", element.getCategory(), -1);
11174    }
11175    if (element.hasExcludedElement()) {
11176      composeBoolean(t, "BenefitBalanceComponent", "excluded", element.getExcludedElement(), -1);
11177    }
11178    if (element.hasNameElement()) {
11179      composeString(t, "BenefitBalanceComponent", "name", element.getNameElement(), -1);
11180    }
11181    if (element.hasDescriptionElement()) {
11182      composeString(t, "BenefitBalanceComponent", "description", element.getDescriptionElement(), -1);
11183    }
11184    if (element.hasNetwork()) {
11185      composeCodeableConcept(t, "BenefitBalanceComponent", "network", element.getNetwork(), -1);
11186    }
11187    if (element.hasUnit()) {
11188      composeCodeableConcept(t, "BenefitBalanceComponent", "unit", element.getUnit(), -1);
11189    }
11190    if (element.hasTerm()) {
11191      composeCodeableConcept(t, "BenefitBalanceComponent", "term", element.getTerm(), -1);
11192    }
11193    for (int i = 0; i < element.getFinancial().size(); i++) {
11194      composeExplanationOfBenefitBenefitComponent(t, "BenefitBalanceComponent", "financial", element.getFinancial().get(i), i);
11195    }
11196  }
11197
11198  protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) {
11199    if (element == null) 
11200      return;
11201    Complex t;
11202    if (Utilities.noString(parentType))
11203      t = parent;
11204    else {
11205      t = parent.predicate("fhir:"+parentType+'.'+name);
11206    }
11207    composeBackboneElement(t, "financial", name, element, index);
11208    if (element.hasType()) {
11209      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
11210    }
11211    if (element.hasAllowed()) {
11212      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
11213    }
11214    if (element.hasUsed()) {
11215      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
11216    }
11217  }
11218
11219  protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) {
11220    if (element == null) 
11221      return;
11222    Complex t;
11223    if (Utilities.noString(parentType))
11224      t = parent;
11225    else {
11226      t = parent.predicate("fhir:"+parentType+'.'+name);
11227    }
11228    composeDomainResource(t, "FamilyMemberHistory", name, element, index);
11229    for (int i = 0; i < element.getIdentifier().size(); i++) {
11230      composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i);
11231    }
11232    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
11233      composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
11234    }
11235    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
11236      composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i);
11237    }
11238    if (element.hasStatusElement()) {
11239      composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1);
11240    }
11241    if (element.hasDataAbsentReason()) {
11242      composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1);
11243    }
11244    if (element.hasPatient()) {
11245      composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1);
11246    }
11247    if (element.hasDateElement()) {
11248      composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1);
11249    }
11250    if (element.hasNameElement()) {
11251      composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1);
11252    }
11253    if (element.hasRelationship()) {
11254      composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1);
11255    }
11256    if (element.hasSex()) {
11257      composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1);
11258    }
11259    if (element.hasBorn()) {
11260      composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1);
11261    }
11262    if (element.hasAge()) {
11263      composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1);
11264    }
11265    if (element.hasEstimatedAgeElement()) {
11266      composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1);
11267    }
11268    if (element.hasDeceased()) {
11269      composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1);
11270    }
11271    for (int i = 0; i < element.getReasonCode().size(); i++) {
11272      composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i);
11273    }
11274    for (int i = 0; i < element.getReasonReference().size(); i++) {
11275      composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i);
11276    }
11277    for (int i = 0; i < element.getNote().size(); i++) {
11278      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
11279    }
11280    for (int i = 0; i < element.getCondition().size(); i++) {
11281      composeFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i);
11282    }
11283  }
11284
11285  protected void composeFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) {
11286    if (element == null) 
11287      return;
11288    Complex t;
11289    if (Utilities.noString(parentType))
11290      t = parent;
11291    else {
11292      t = parent.predicate("fhir:"+parentType+'.'+name);
11293    }
11294    composeBackboneElement(t, "condition", name, element, index);
11295    if (element.hasCode()) {
11296      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "code", element.getCode(), -1);
11297    }
11298    if (element.hasOutcome()) {
11299      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "outcome", element.getOutcome(), -1);
11300    }
11301    if (element.hasContributedToDeathElement()) {
11302      composeBoolean(t, "FamilyMemberHistoryConditionComponent", "contributedToDeath", element.getContributedToDeathElement(), -1);
11303    }
11304    if (element.hasOnset()) {
11305      composeType(t, "FamilyMemberHistoryConditionComponent", "onset", element.getOnset(), -1);
11306    }
11307    for (int i = 0; i < element.getNote().size(); i++) {
11308      composeAnnotation(t, "FamilyMemberHistoryConditionComponent", "note", element.getNote().get(i), i);
11309    }
11310  }
11311
11312  protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) {
11313    if (element == null) 
11314      return;
11315    Complex t;
11316    if (Utilities.noString(parentType))
11317      t = parent;
11318    else {
11319      t = parent.predicate("fhir:"+parentType+'.'+name);
11320    }
11321    composeDomainResource(t, "Flag", name, element, index);
11322    for (int i = 0; i < element.getIdentifier().size(); i++) {
11323      composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i);
11324    }
11325    if (element.hasStatusElement()) {
11326      composeEnum(t, "Flag", "status", element.getStatusElement(), -1);
11327    }
11328    for (int i = 0; i < element.getCategory().size(); i++) {
11329      composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i);
11330    }
11331    if (element.hasCode()) {
11332      composeCodeableConcept(t, "Flag", "code", element.getCode(), -1);
11333    }
11334    if (element.hasSubject()) {
11335      composeReference(t, "Flag", "subject", element.getSubject(), -1);
11336    }
11337    if (element.hasPeriod()) {
11338      composePeriod(t, "Flag", "period", element.getPeriod(), -1);
11339    }
11340    if (element.hasEncounter()) {
11341      composeReference(t, "Flag", "encounter", element.getEncounter(), -1);
11342    }
11343    if (element.hasAuthor()) {
11344      composeReference(t, "Flag", "author", element.getAuthor(), -1);
11345    }
11346  }
11347
11348  protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) {
11349    if (element == null) 
11350      return;
11351    Complex t;
11352    if (Utilities.noString(parentType))
11353      t = parent;
11354    else {
11355      t = parent.predicate("fhir:"+parentType+'.'+name);
11356    }
11357    composeDomainResource(t, "Goal", name, element, index);
11358    for (int i = 0; i < element.getIdentifier().size(); i++) {
11359      composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i);
11360    }
11361    if (element.hasLifecycleStatusElement()) {
11362      composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1);
11363    }
11364    if (element.hasAchievementStatus()) {
11365      composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1);
11366    }
11367    for (int i = 0; i < element.getCategory().size(); i++) {
11368      composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i);
11369    }
11370    if (element.hasPriority()) {
11371      composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1);
11372    }
11373    if (element.hasDescription()) {
11374      composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1);
11375    }
11376    if (element.hasSubject()) {
11377      composeReference(t, "Goal", "subject", element.getSubject(), -1);
11378    }
11379    if (element.hasStart()) {
11380      composeType(t, "Goal", "start", element.getStart(), -1);
11381    }
11382    for (int i = 0; i < element.getTarget().size(); i++) {
11383      composeGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i);
11384    }
11385    if (element.hasStatusDateElement()) {
11386      composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1);
11387    }
11388    if (element.hasStatusReasonElement()) {
11389      composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1);
11390    }
11391    if (element.hasExpressedBy()) {
11392      composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1);
11393    }
11394    for (int i = 0; i < element.getAddresses().size(); i++) {
11395      composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i);
11396    }
11397    for (int i = 0; i < element.getNote().size(); i++) {
11398      composeAnnotation(t, "Goal", "note", element.getNote().get(i), i);
11399    }
11400    for (int i = 0; i < element.getOutcomeCode().size(); i++) {
11401      composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i);
11402    }
11403    for (int i = 0; i < element.getOutcomeReference().size(); i++) {
11404      composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i);
11405    }
11406  }
11407
11408  protected void composeGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) {
11409    if (element == null) 
11410      return;
11411    Complex t;
11412    if (Utilities.noString(parentType))
11413      t = parent;
11414    else {
11415      t = parent.predicate("fhir:"+parentType+'.'+name);
11416    }
11417    composeBackboneElement(t, "target", name, element, index);
11418    if (element.hasMeasure()) {
11419      composeCodeableConcept(t, "GoalTargetComponent", "measure", element.getMeasure(), -1);
11420    }
11421    if (element.hasDetail()) {
11422      composeType(t, "GoalTargetComponent", "detail", element.getDetail(), -1);
11423    }
11424    if (element.hasDue()) {
11425      composeType(t, "GoalTargetComponent", "due", element.getDue(), -1);
11426    }
11427  }
11428
11429  protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) {
11430    if (element == null) 
11431      return;
11432    Complex t;
11433    if (Utilities.noString(parentType))
11434      t = parent;
11435    else {
11436      t = parent.predicate("fhir:"+parentType+'.'+name);
11437    }
11438    composeDomainResource(t, "GraphDefinition", name, element, index);
11439    if (element.hasUrlElement()) {
11440      composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1);
11441    }
11442    if (element.hasVersionElement()) {
11443      composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1);
11444    }
11445    if (element.hasNameElement()) {
11446      composeString(t, "GraphDefinition", "name", element.getNameElement(), -1);
11447    }
11448    if (element.hasStatusElement()) {
11449      composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1);
11450    }
11451    if (element.hasExperimentalElement()) {
11452      composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1);
11453    }
11454    if (element.hasDateElement()) {
11455      composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1);
11456    }
11457    if (element.hasPublisherElement()) {
11458      composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1);
11459    }
11460    for (int i = 0; i < element.getContact().size(); i++) {
11461      composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i);
11462    }
11463    if (element.hasDescriptionElement()) {
11464      composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
11465    }
11466    for (int i = 0; i < element.getUseContext().size(); i++) {
11467      composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i);
11468    }
11469    for (int i = 0; i < element.getJurisdiction().size(); i++) {
11470      composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
11471    }
11472    if (element.hasPurposeElement()) {
11473      composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1);
11474    }
11475    if (element.hasStartElement()) {
11476      composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1);
11477    }
11478    if (element.hasProfileElement()) {
11479      composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
11480    }
11481    for (int i = 0; i < element.getLink().size(); i++) {
11482      composeGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
11483    }
11484  }
11485
11486  protected void composeGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) {
11487    if (element == null) 
11488      return;
11489    Complex t;
11490    if (Utilities.noString(parentType))
11491      t = parent;
11492    else {
11493      t = parent.predicate("fhir:"+parentType+'.'+name);
11494    }
11495    composeBackboneElement(t, "link", name, element, index);
11496    if (element.hasPathElement()) {
11497      composeString(t, "GraphDefinitionLinkComponent", "path", element.getPathElement(), -1);
11498    }
11499    if (element.hasSliceNameElement()) {
11500      composeString(t, "GraphDefinitionLinkComponent", "sliceName", element.getSliceNameElement(), -1);
11501    }
11502    if (element.hasMinElement()) {
11503      composeInteger(t, "GraphDefinitionLinkComponent", "min", element.getMinElement(), -1);
11504    }
11505    if (element.hasMaxElement()) {
11506      composeString(t, "GraphDefinitionLinkComponent", "max", element.getMaxElement(), -1);
11507    }
11508    if (element.hasDescriptionElement()) {
11509      composeString(t, "GraphDefinitionLinkComponent", "description", element.getDescriptionElement(), -1);
11510    }
11511    for (int i = 0; i < element.getTarget().size(); i++) {
11512      composeGraphDefinitionLinkTargetComponent(t, "GraphDefinitionLinkComponent", "target", element.getTarget().get(i), i);
11513    }
11514  }
11515
11516  protected void composeGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) {
11517    if (element == null) 
11518      return;
11519    Complex t;
11520    if (Utilities.noString(parentType))
11521      t = parent;
11522    else {
11523      t = parent.predicate("fhir:"+parentType+'.'+name);
11524    }
11525    composeBackboneElement(t, "target", name, element, index);
11526    if (element.hasTypeElement()) {
11527      composeCode(t, "GraphDefinitionLinkTargetComponent", "type", element.getTypeElement(), -1);
11528    }
11529    if (element.hasParamsElement()) {
11530      composeString(t, "GraphDefinitionLinkTargetComponent", "params", element.getParamsElement(), -1);
11531    }
11532    if (element.hasProfileElement()) {
11533      composeCanonical(t, "GraphDefinitionLinkTargetComponent", "profile", element.getProfileElement(), -1);
11534    }
11535    for (int i = 0; i < element.getCompartment().size(); i++) {
11536      composeGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinitionLinkTargetComponent", "compartment", element.getCompartment().get(i), i);
11537    }
11538    for (int i = 0; i < element.getLink().size(); i++) {
11539      composeGraphDefinitionLinkComponent(t, "GraphDefinitionLinkTargetComponent", "link", element.getLink().get(i), i);
11540    }
11541  }
11542
11543  protected void composeGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) {
11544    if (element == null) 
11545      return;
11546    Complex t;
11547    if (Utilities.noString(parentType))
11548      t = parent;
11549    else {
11550      t = parent.predicate("fhir:"+parentType+'.'+name);
11551    }
11552    composeBackboneElement(t, "compartment", name, element, index);
11553    if (element.hasUseElement()) {
11554      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "use", element.getUseElement(), -1);
11555    }
11556    if (element.hasCodeElement()) {
11557      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "code", element.getCodeElement(), -1);
11558    }
11559    if (element.hasRuleElement()) {
11560      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "rule", element.getRuleElement(), -1);
11561    }
11562    if (element.hasExpressionElement()) {
11563      composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "expression", element.getExpressionElement(), -1);
11564    }
11565    if (element.hasDescriptionElement()) {
11566      composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "description", element.getDescriptionElement(), -1);
11567    }
11568  }
11569
11570  protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) {
11571    if (element == null) 
11572      return;
11573    Complex t;
11574    if (Utilities.noString(parentType))
11575      t = parent;
11576    else {
11577      t = parent.predicate("fhir:"+parentType+'.'+name);
11578    }
11579    composeDomainResource(t, "Group", name, element, index);
11580    for (int i = 0; i < element.getIdentifier().size(); i++) {
11581      composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i);
11582    }
11583    if (element.hasActiveElement()) {
11584      composeBoolean(t, "Group", "active", element.getActiveElement(), -1);
11585    }
11586    if (element.hasTypeElement()) {
11587      composeEnum(t, "Group", "type", element.getTypeElement(), -1);
11588    }
11589    if (element.hasActualElement()) {
11590      composeBoolean(t, "Group", "actual", element.getActualElement(), -1);
11591    }
11592    if (element.hasCode()) {
11593      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
11594    }
11595    if (element.hasNameElement()) {
11596      composeString(t, "Group", "name", element.getNameElement(), -1);
11597    }
11598    if (element.hasQuantityElement()) {
11599      composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1);
11600    }
11601    if (element.hasManagingEntity()) {
11602      composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1);
11603    }
11604    for (int i = 0; i < element.getCharacteristic().size(); i++) {
11605      composeGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i);
11606    }
11607    for (int i = 0; i < element.getMember().size(); i++) {
11608      composeGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i);
11609    }
11610  }
11611
11612  protected void composeGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) {
11613    if (element == null) 
11614      return;
11615    Complex t;
11616    if (Utilities.noString(parentType))
11617      t = parent;
11618    else {
11619      t = parent.predicate("fhir:"+parentType+'.'+name);
11620    }
11621    composeBackboneElement(t, "characteristic", name, element, index);
11622    if (element.hasCode()) {
11623      composeCodeableConcept(t, "GroupCharacteristicComponent", "code", element.getCode(), -1);
11624    }
11625    if (element.hasValue()) {
11626      composeType(t, "GroupCharacteristicComponent", "value", element.getValue(), -1);
11627    }
11628    if (element.hasExcludeElement()) {
11629      composeBoolean(t, "GroupCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
11630    }
11631    if (element.hasPeriod()) {
11632      composePeriod(t, "GroupCharacteristicComponent", "period", element.getPeriod(), -1);
11633    }
11634  }
11635
11636  protected void composeGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) {
11637    if (element == null) 
11638      return;
11639    Complex t;
11640    if (Utilities.noString(parentType))
11641      t = parent;
11642    else {
11643      t = parent.predicate("fhir:"+parentType+'.'+name);
11644    }
11645    composeBackboneElement(t, "member", name, element, index);
11646    if (element.hasEntity()) {
11647      composeReference(t, "GroupMemberComponent", "entity", element.getEntity(), -1);
11648    }
11649    if (element.hasPeriod()) {
11650      composePeriod(t, "GroupMemberComponent", "period", element.getPeriod(), -1);
11651    }
11652    if (element.hasInactiveElement()) {
11653      composeBoolean(t, "GroupMemberComponent", "inactive", element.getInactiveElement(), -1);
11654    }
11655  }
11656
11657  protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) {
11658    if (element == null) 
11659      return;
11660    Complex t;
11661    if (Utilities.noString(parentType))
11662      t = parent;
11663    else {
11664      t = parent.predicate("fhir:"+parentType+'.'+name);
11665    }
11666    composeDomainResource(t, "GuidanceResponse", name, element, index);
11667    if (element.hasRequestIdentifier()) {
11668      composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1);
11669    }
11670    for (int i = 0; i < element.getIdentifier().size(); i++) {
11671      composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i);
11672    }
11673    if (element.hasModule()) {
11674      composeType(t, "GuidanceResponse", "module", element.getModule(), -1);
11675    }
11676    if (element.hasStatusElement()) {
11677      composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1);
11678    }
11679    if (element.hasSubject()) {
11680      composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1);
11681    }
11682    if (element.hasEncounter()) {
11683      composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1);
11684    }
11685    if (element.hasOccurrenceDateTimeElement()) {
11686      composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1);
11687    }
11688    if (element.hasPerformer()) {
11689      composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1);
11690    }
11691    for (int i = 0; i < element.getReasonCode().size(); i++) {
11692      composeCodeableConcept(t, "GuidanceResponse", "reasonCode", element.getReasonCode().get(i), i);
11693    }
11694    for (int i = 0; i < element.getReasonReference().size(); i++) {
11695      composeReference(t, "GuidanceResponse", "reasonReference", element.getReasonReference().get(i), i);
11696    }
11697    for (int i = 0; i < element.getNote().size(); i++) {
11698      composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i);
11699    }
11700    for (int i = 0; i < element.getEvaluationMessage().size(); i++) {
11701      composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i);
11702    }
11703    if (element.hasOutputParameters()) {
11704      composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1);
11705    }
11706    if (element.hasResult()) {
11707      composeReference(t, "GuidanceResponse", "result", element.getResult(), -1);
11708    }
11709    for (int i = 0; i < element.getDataRequirement().size(); i++) {
11710      composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i);
11711    }
11712  }
11713
11714  protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) {
11715    if (element == null) 
11716      return;
11717    Complex t;
11718    if (Utilities.noString(parentType))
11719      t = parent;
11720    else {
11721      t = parent.predicate("fhir:"+parentType+'.'+name);
11722    }
11723    composeDomainResource(t, "HealthcareService", name, element, index);
11724    for (int i = 0; i < element.getIdentifier().size(); i++) {
11725      composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i);
11726    }
11727    if (element.hasActiveElement()) {
11728      composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1);
11729    }
11730    if (element.hasProvidedBy()) {
11731      composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1);
11732    }
11733    for (int i = 0; i < element.getCategory().size(); i++) {
11734      composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i);
11735    }
11736    for (int i = 0; i < element.getType().size(); i++) {
11737      composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i);
11738    }
11739    for (int i = 0; i < element.getSpecialty().size(); i++) {
11740      composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i);
11741    }
11742    for (int i = 0; i < element.getLocation().size(); i++) {
11743      composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i);
11744    }
11745    if (element.hasNameElement()) {
11746      composeString(t, "HealthcareService", "name", element.getNameElement(), -1);
11747    }
11748    if (element.hasCommentElement()) {
11749      composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1);
11750    }
11751    if (element.hasExtraDetailsElement()) {
11752      composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1);
11753    }
11754    if (element.hasPhoto()) {
11755      composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1);
11756    }
11757    for (int i = 0; i < element.getTelecom().size(); i++) {
11758      composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i);
11759    }
11760    for (int i = 0; i < element.getCoverageArea().size(); i++) {
11761      composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i);
11762    }
11763    for (int i = 0; i < element.getServiceProvisionCode().size(); i++) {
11764      composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i);
11765    }
11766    for (int i = 0; i < element.getEligibility().size(); i++) {
11767      composeHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i);
11768    }
11769    for (int i = 0; i < element.getProgram().size(); i++) {
11770      composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i);
11771    }
11772    for (int i = 0; i < element.getCharacteristic().size(); i++) {
11773      composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i);
11774    }
11775    for (int i = 0; i < element.getCommunication().size(); i++) {
11776      composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i);
11777    }
11778    for (int i = 0; i < element.getReferralMethod().size(); i++) {
11779      composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i);
11780    }
11781    if (element.hasAppointmentRequiredElement()) {
11782      composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1);
11783    }
11784    for (int i = 0; i < element.getAvailableTime().size(); i++) {
11785      composeHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i);
11786    }
11787    for (int i = 0; i < element.getNotAvailable().size(); i++) {
11788      composeHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i);
11789    }
11790    if (element.hasAvailabilityExceptionsElement()) {
11791      composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
11792    }
11793    for (int i = 0; i < element.getEndpoint().size(); i++) {
11794      composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i);
11795    }
11796  }
11797
11798  protected void composeHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent element, int index) {
11799    if (element == null) 
11800      return;
11801    Complex t;
11802    if (Utilities.noString(parentType))
11803      t = parent;
11804    else {
11805      t = parent.predicate("fhir:"+parentType+'.'+name);
11806    }
11807    composeBackboneElement(t, "eligibility", name, element, index);
11808    if (element.hasCode()) {
11809      composeCodeableConcept(t, "HealthcareServiceEligibilityComponent", "code", element.getCode(), -1);
11810    }
11811    if (element.hasCommentElement()) {
11812      composeMarkdown(t, "HealthcareServiceEligibilityComponent", "comment", element.getCommentElement(), -1);
11813    }
11814  }
11815
11816  protected void composeHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) {
11817    if (element == null) 
11818      return;
11819    Complex t;
11820    if (Utilities.noString(parentType))
11821      t = parent;
11822    else {
11823      t = parent.predicate("fhir:"+parentType+'.'+name);
11824    }
11825    composeBackboneElement(t, "availableTime", name, element, index);
11826    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
11827      composeEnum(t, "HealthcareServiceAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
11828    }
11829    if (element.hasAllDayElement()) {
11830      composeBoolean(t, "HealthcareServiceAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
11831    }
11832    if (element.hasAvailableStartTimeElement()) {
11833      composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
11834    }
11835    if (element.hasAvailableEndTimeElement()) {
11836      composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
11837    }
11838  }
11839
11840  protected void composeHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) {
11841    if (element == null) 
11842      return;
11843    Complex t;
11844    if (Utilities.noString(parentType))
11845      t = parent;
11846    else {
11847      t = parent.predicate("fhir:"+parentType+'.'+name);
11848    }
11849    composeBackboneElement(t, "notAvailable", name, element, index);
11850    if (element.hasDescriptionElement()) {
11851      composeString(t, "HealthcareServiceNotAvailableComponent", "description", element.getDescriptionElement(), -1);
11852    }
11853    if (element.hasDuring()) {
11854      composePeriod(t, "HealthcareServiceNotAvailableComponent", "during", element.getDuring(), -1);
11855    }
11856  }
11857
11858  protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) {
11859    if (element == null) 
11860      return;
11861    Complex t;
11862    if (Utilities.noString(parentType))
11863      t = parent;
11864    else {
11865      t = parent.predicate("fhir:"+parentType+'.'+name);
11866    }
11867    composeDomainResource(t, "ImagingStudy", name, element, index);
11868    for (int i = 0; i < element.getIdentifier().size(); i++) {
11869      composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i);
11870    }
11871    if (element.hasStatusElement()) {
11872      composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1);
11873    }
11874    for (int i = 0; i < element.getModality().size(); i++) {
11875      composeCoding(t, "ImagingStudy", "modality", element.getModality().get(i), i);
11876    }
11877    if (element.hasSubject()) {
11878      composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1);
11879    }
11880    if (element.hasEncounter()) {
11881      composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1);
11882    }
11883    if (element.hasStartedElement()) {
11884      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
11885    }
11886    for (int i = 0; i < element.getBasedOn().size(); i++) {
11887      composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i);
11888    }
11889    if (element.hasReferrer()) {
11890      composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1);
11891    }
11892    for (int i = 0; i < element.getInterpreter().size(); i++) {
11893      composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i);
11894    }
11895    for (int i = 0; i < element.getEndpoint().size(); i++) {
11896      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
11897    }
11898    if (element.hasNumberOfSeriesElement()) {
11899      composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1);
11900    }
11901    if (element.hasNumberOfInstancesElement()) {
11902      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
11903    }
11904    if (element.hasProcedureReference()) {
11905      composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference(), -1);
11906    }
11907    for (int i = 0; i < element.getProcedureCode().size(); i++) {
11908      composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i);
11909    }
11910    if (element.hasLocation()) {
11911      composeReference(t, "ImagingStudy", "location", element.getLocation(), -1);
11912    }
11913    for (int i = 0; i < element.getReasonCode().size(); i++) {
11914      composeCodeableConcept(t, "ImagingStudy", "reasonCode", element.getReasonCode().get(i), i);
11915    }
11916    for (int i = 0; i < element.getReasonReference().size(); i++) {
11917      composeReference(t, "ImagingStudy", "reasonReference", element.getReasonReference().get(i), i);
11918    }
11919    for (int i = 0; i < element.getNote().size(); i++) {
11920      composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i);
11921    }
11922    if (element.hasDescriptionElement()) {
11923      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
11924    }
11925    for (int i = 0; i < element.getSeries().size(); i++) {
11926      composeImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i);
11927    }
11928  }
11929
11930  protected void composeImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) {
11931    if (element == null) 
11932      return;
11933    Complex t;
11934    if (Utilities.noString(parentType))
11935      t = parent;
11936    else {
11937      t = parent.predicate("fhir:"+parentType+'.'+name);
11938    }
11939    composeBackboneElement(t, "series", name, element, index);
11940    if (element.hasUidElement()) {
11941      composeId(t, "ImagingStudySeriesComponent", "uid", element.getUidElement(), -1);
11942    }
11943    if (element.hasNumberElement()) {
11944      composeUnsignedInt(t, "ImagingStudySeriesComponent", "number", element.getNumberElement(), -1);
11945    }
11946    if (element.hasModality()) {
11947      composeCoding(t, "ImagingStudySeriesComponent", "modality", element.getModality(), -1);
11948    }
11949    if (element.hasDescriptionElement()) {
11950      composeString(t, "ImagingStudySeriesComponent", "description", element.getDescriptionElement(), -1);
11951    }
11952    if (element.hasNumberOfInstancesElement()) {
11953      composeUnsignedInt(t, "ImagingStudySeriesComponent", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
11954    }
11955    for (int i = 0; i < element.getEndpoint().size(); i++) {
11956      composeReference(t, "ImagingStudySeriesComponent", "endpoint", element.getEndpoint().get(i), i);
11957    }
11958    if (element.hasBodySite()) {
11959      composeCoding(t, "ImagingStudySeriesComponent", "bodySite", element.getBodySite(), -1);
11960    }
11961    if (element.hasLaterality()) {
11962      composeCoding(t, "ImagingStudySeriesComponent", "laterality", element.getLaterality(), -1);
11963    }
11964    for (int i = 0; i < element.getSpecimen().size(); i++) {
11965      composeReference(t, "ImagingStudySeriesComponent", "specimen", element.getSpecimen().get(i), i);
11966    }
11967    if (element.hasStartedElement()) {
11968      composeDateTime(t, "ImagingStudySeriesComponent", "started", element.getStartedElement(), -1);
11969    }
11970    for (int i = 0; i < element.getPerformer().size(); i++) {
11971      composeImagingStudySeriesPerformerComponent(t, "ImagingStudySeriesComponent", "performer", element.getPerformer().get(i), i);
11972    }
11973    for (int i = 0; i < element.getInstance().size(); i++) {
11974      composeImagingStudySeriesInstanceComponent(t, "ImagingStudySeriesComponent", "instance", element.getInstance().get(i), i);
11975    }
11976  }
11977
11978  protected void composeImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent element, int index) {
11979    if (element == null) 
11980      return;
11981    Complex t;
11982    if (Utilities.noString(parentType))
11983      t = parent;
11984    else {
11985      t = parent.predicate("fhir:"+parentType+'.'+name);
11986    }
11987    composeBackboneElement(t, "performer", name, element, index);
11988    if (element.hasFunction()) {
11989      composeCodeableConcept(t, "ImagingStudySeriesPerformerComponent", "function", element.getFunction(), -1);
11990    }
11991    if (element.hasActor()) {
11992      composeReference(t, "ImagingStudySeriesPerformerComponent", "actor", element.getActor(), -1);
11993    }
11994  }
11995
11996  protected void composeImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) {
11997    if (element == null) 
11998      return;
11999    Complex t;
12000    if (Utilities.noString(parentType))
12001      t = parent;
12002    else {
12003      t = parent.predicate("fhir:"+parentType+'.'+name);
12004    }
12005    composeBackboneElement(t, "instance", name, element, index);
12006    if (element.hasUidElement()) {
12007      composeId(t, "ImagingStudySeriesInstanceComponent", "uid", element.getUidElement(), -1);
12008    }
12009    if (element.hasSopClass()) {
12010      composeCoding(t, "ImagingStudySeriesInstanceComponent", "sopClass", element.getSopClass(), -1);
12011    }
12012    if (element.hasNumberElement()) {
12013      composeUnsignedInt(t, "ImagingStudySeriesInstanceComponent", "number", element.getNumberElement(), -1);
12014    }
12015    if (element.hasTitleElement()) {
12016      composeString(t, "ImagingStudySeriesInstanceComponent", "title", element.getTitleElement(), -1);
12017    }
12018  }
12019
12020  protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) {
12021    if (element == null) 
12022      return;
12023    Complex t;
12024    if (Utilities.noString(parentType))
12025      t = parent;
12026    else {
12027      t = parent.predicate("fhir:"+parentType+'.'+name);
12028    }
12029    composeDomainResource(t, "Immunization", name, element, index);
12030    for (int i = 0; i < element.getIdentifier().size(); i++) {
12031      composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i);
12032    }
12033    if (element.hasStatusElement()) {
12034      composeEnum(t, "Immunization", "status", element.getStatusElement(), -1);
12035    }
12036    if (element.hasStatusReason()) {
12037      composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1);
12038    }
12039    if (element.hasVaccineCode()) {
12040      composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1);
12041    }
12042    if (element.hasPatient()) {
12043      composeReference(t, "Immunization", "patient", element.getPatient(), -1);
12044    }
12045    if (element.hasEncounter()) {
12046      composeReference(t, "Immunization", "encounter", element.getEncounter(), -1);
12047    }
12048    if (element.hasOccurrence()) {
12049      composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1);
12050    }
12051    if (element.hasRecordedElement()) {
12052      composeDateTime(t, "Immunization", "recorded", element.getRecordedElement(), -1);
12053    }
12054    if (element.hasPrimarySourceElement()) {
12055      composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1);
12056    }
12057    if (element.hasReportOrigin()) {
12058      composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1);
12059    }
12060    if (element.hasLocation()) {
12061      composeReference(t, "Immunization", "location", element.getLocation(), -1);
12062    }
12063    if (element.hasManufacturer()) {
12064      composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1);
12065    }
12066    if (element.hasLotNumberElement()) {
12067      composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1);
12068    }
12069    if (element.hasExpirationDateElement()) {
12070      composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1);
12071    }
12072    if (element.hasSite()) {
12073      composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1);
12074    }
12075    if (element.hasRoute()) {
12076      composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1);
12077    }
12078    if (element.hasDoseQuantity()) {
12079      composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1);
12080    }
12081    for (int i = 0; i < element.getPerformer().size(); i++) {
12082      composeImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i);
12083    }
12084    for (int i = 0; i < element.getNote().size(); i++) {
12085      composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i);
12086    }
12087    for (int i = 0; i < element.getReasonCode().size(); i++) {
12088      composeCodeableConcept(t, "Immunization", "reasonCode", element.getReasonCode().get(i), i);
12089    }
12090    for (int i = 0; i < element.getReasonReference().size(); i++) {
12091      composeReference(t, "Immunization", "reasonReference", element.getReasonReference().get(i), i);
12092    }
12093    if (element.hasIsSubpotentElement()) {
12094      composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1);
12095    }
12096    for (int i = 0; i < element.getSubpotentReason().size(); i++) {
12097      composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i);
12098    }
12099    for (int i = 0; i < element.getEducation().size(); i++) {
12100      composeImmunizationEducationComponent(t, "Immunization", "education", element.getEducation().get(i), i);
12101    }
12102    for (int i = 0; i < element.getProgramEligibility().size(); i++) {
12103      composeCodeableConcept(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i);
12104    }
12105    if (element.hasFundingSource()) {
12106      composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1);
12107    }
12108    for (int i = 0; i < element.getReaction().size(); i++) {
12109      composeImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i);
12110    }
12111    for (int i = 0; i < element.getProtocolApplied().size(); i++) {
12112      composeImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i);
12113    }
12114  }
12115
12116  protected void composeImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent element, int index) {
12117    if (element == null) 
12118      return;
12119    Complex t;
12120    if (Utilities.noString(parentType))
12121      t = parent;
12122    else {
12123      t = parent.predicate("fhir:"+parentType+'.'+name);
12124    }
12125    composeBackboneElement(t, "performer", name, element, index);
12126    if (element.hasFunction()) {
12127      composeCodeableConcept(t, "ImmunizationPerformerComponent", "function", element.getFunction(), -1);
12128    }
12129    if (element.hasActor()) {
12130      composeReference(t, "ImmunizationPerformerComponent", "actor", element.getActor(), -1);
12131    }
12132  }
12133
12134  protected void composeImmunizationEducationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationEducationComponent element, int index) {
12135    if (element == null) 
12136      return;
12137    Complex t;
12138    if (Utilities.noString(parentType))
12139      t = parent;
12140    else {
12141      t = parent.predicate("fhir:"+parentType+'.'+name);
12142    }
12143    composeBackboneElement(t, "education", name, element, index);
12144    if (element.hasDocumentTypeElement()) {
12145      composeString(t, "ImmunizationEducationComponent", "documentType", element.getDocumentTypeElement(), -1);
12146    }
12147    if (element.hasReferenceElement()) {
12148      composeUri(t, "ImmunizationEducationComponent", "reference", element.getReferenceElement(), -1);
12149    }
12150    if (element.hasPublicationDateElement()) {
12151      composeDateTime(t, "ImmunizationEducationComponent", "publicationDate", element.getPublicationDateElement(), -1);
12152    }
12153    if (element.hasPresentationDateElement()) {
12154      composeDateTime(t, "ImmunizationEducationComponent", "presentationDate", element.getPresentationDateElement(), -1);
12155    }
12156  }
12157
12158  protected void composeImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) {
12159    if (element == null) 
12160      return;
12161    Complex t;
12162    if (Utilities.noString(parentType))
12163      t = parent;
12164    else {
12165      t = parent.predicate("fhir:"+parentType+'.'+name);
12166    }
12167    composeBackboneElement(t, "reaction", name, element, index);
12168    if (element.hasDateElement()) {
12169      composeDateTime(t, "ImmunizationReactionComponent", "date", element.getDateElement(), -1);
12170    }
12171    if (element.hasDetail()) {
12172      composeReference(t, "ImmunizationReactionComponent", "detail", element.getDetail(), -1);
12173    }
12174    if (element.hasReportedElement()) {
12175      composeBoolean(t, "ImmunizationReactionComponent", "reported", element.getReportedElement(), -1);
12176    }
12177  }
12178
12179  protected void composeImmunizationProtocolAppliedComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProtocolAppliedComponent element, int index) {
12180    if (element == null) 
12181      return;
12182    Complex t;
12183    if (Utilities.noString(parentType))
12184      t = parent;
12185    else {
12186      t = parent.predicate("fhir:"+parentType+'.'+name);
12187    }
12188    composeBackboneElement(t, "protocolApplied", name, element, index);
12189    if (element.hasSeriesElement()) {
12190      composeString(t, "ImmunizationProtocolAppliedComponent", "series", element.getSeriesElement(), -1);
12191    }
12192    if (element.hasAuthority()) {
12193      composeReference(t, "ImmunizationProtocolAppliedComponent", "authority", element.getAuthority(), -1);
12194    }
12195    for (int i = 0; i < element.getTargetDisease().size(); i++) {
12196      composeCodeableConcept(t, "ImmunizationProtocolAppliedComponent", "targetDisease", element.getTargetDisease().get(i), i);
12197    }
12198    if (element.hasDoseNumber()) {
12199      composeType(t, "ImmunizationProtocolAppliedComponent", "doseNumber", element.getDoseNumber(), -1);
12200    }
12201    if (element.hasSeriesDoses()) {
12202      composeType(t, "ImmunizationProtocolAppliedComponent", "seriesDoses", element.getSeriesDoses(), -1);
12203    }
12204  }
12205
12206  protected void composeImmunizationEvaluation(Complex parent, String parentType, String name, ImmunizationEvaluation element, int index) {
12207    if (element == null) 
12208      return;
12209    Complex t;
12210    if (Utilities.noString(parentType))
12211      t = parent;
12212    else {
12213      t = parent.predicate("fhir:"+parentType+'.'+name);
12214    }
12215    composeDomainResource(t, "ImmunizationEvaluation", name, element, index);
12216    for (int i = 0; i < element.getIdentifier().size(); i++) {
12217      composeIdentifier(t, "ImmunizationEvaluation", "identifier", element.getIdentifier().get(i), i);
12218    }
12219    if (element.hasStatusElement()) {
12220      composeEnum(t, "ImmunizationEvaluation", "status", element.getStatusElement(), -1);
12221    }
12222    if (element.hasPatient()) {
12223      composeReference(t, "ImmunizationEvaluation", "patient", element.getPatient(), -1);
12224    }
12225    if (element.hasDateElement()) {
12226      composeDateTime(t, "ImmunizationEvaluation", "date", element.getDateElement(), -1);
12227    }
12228    if (element.hasAuthority()) {
12229      composeReference(t, "ImmunizationEvaluation", "authority", element.getAuthority(), -1);
12230    }
12231    if (element.hasTargetDisease()) {
12232      composeCodeableConcept(t, "ImmunizationEvaluation", "targetDisease", element.getTargetDisease(), -1);
12233    }
12234    if (element.hasImmunizationEvent()) {
12235      composeReference(t, "ImmunizationEvaluation", "immunizationEvent", element.getImmunizationEvent(), -1);
12236    }
12237    if (element.hasDoseStatus()) {
12238      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatus", element.getDoseStatus(), -1);
12239    }
12240    for (int i = 0; i < element.getDoseStatusReason().size(); i++) {
12241      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatusReason", element.getDoseStatusReason().get(i), i);
12242    }
12243    if (element.hasDescriptionElement()) {
12244      composeString(t, "ImmunizationEvaluation", "description", element.getDescriptionElement(), -1);
12245    }
12246    if (element.hasSeriesElement()) {
12247      composeString(t, "ImmunizationEvaluation", "series", element.getSeriesElement(), -1);
12248    }
12249    if (element.hasDoseNumber()) {
12250      composeType(t, "ImmunizationEvaluation", "doseNumber", element.getDoseNumber(), -1);
12251    }
12252    if (element.hasSeriesDoses()) {
12253      composeType(t, "ImmunizationEvaluation", "seriesDoses", element.getSeriesDoses(), -1);
12254    }
12255  }
12256
12257  protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) {
12258    if (element == null) 
12259      return;
12260    Complex t;
12261    if (Utilities.noString(parentType))
12262      t = parent;
12263    else {
12264      t = parent.predicate("fhir:"+parentType+'.'+name);
12265    }
12266    composeDomainResource(t, "ImmunizationRecommendation", name, element, index);
12267    for (int i = 0; i < element.getIdentifier().size(); i++) {
12268      composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i);
12269    }
12270    if (element.hasPatient()) {
12271      composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1);
12272    }
12273    if (element.hasDateElement()) {
12274      composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1);
12275    }
12276    if (element.hasAuthority()) {
12277      composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1);
12278    }
12279    for (int i = 0; i < element.getRecommendation().size(); i++) {
12280      composeImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i);
12281    }
12282  }
12283
12284  protected void composeImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) {
12285    if (element == null) 
12286      return;
12287    Complex t;
12288    if (Utilities.noString(parentType))
12289      t = parent;
12290    else {
12291      t = parent.predicate("fhir:"+parentType+'.'+name);
12292    }
12293    composeBackboneElement(t, "recommendation", name, element, index);
12294    for (int i = 0; i < element.getVaccineCode().size(); i++) {
12295      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "vaccineCode", element.getVaccineCode().get(i), i);
12296    }
12297    if (element.hasTargetDisease()) {
12298      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "targetDisease", element.getTargetDisease(), -1);
12299    }
12300    for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) {
12301      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "contraindicatedVaccineCode", element.getContraindicatedVaccineCode().get(i), i);
12302    }
12303    if (element.hasForecastStatus()) {
12304      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastStatus", element.getForecastStatus(), -1);
12305    }
12306    for (int i = 0; i < element.getForecastReason().size(); i++) {
12307      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastReason", element.getForecastReason().get(i), i);
12308    }
12309    for (int i = 0; i < element.getDateCriterion().size(); i++) {
12310      composeImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendationRecommendationComponent", "dateCriterion", element.getDateCriterion().get(i), i);
12311    }
12312    if (element.hasDescriptionElement()) {
12313      composeString(t, "ImmunizationRecommendationRecommendationComponent", "description", element.getDescriptionElement(), -1);
12314    }
12315    if (element.hasSeriesElement()) {
12316      composeString(t, "ImmunizationRecommendationRecommendationComponent", "series", element.getSeriesElement(), -1);
12317    }
12318    if (element.hasDoseNumber()) {
12319      composeType(t, "ImmunizationRecommendationRecommendationComponent", "doseNumber", element.getDoseNumber(), -1);
12320    }
12321    if (element.hasSeriesDoses()) {
12322      composeType(t, "ImmunizationRecommendationRecommendationComponent", "seriesDoses", element.getSeriesDoses(), -1);
12323    }
12324    for (int i = 0; i < element.getSupportingImmunization().size(); i++) {
12325      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingImmunization", element.getSupportingImmunization().get(i), i);
12326    }
12327    for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) {
12328      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i);
12329    }
12330  }
12331
12332  protected void composeImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) {
12333    if (element == null) 
12334      return;
12335    Complex t;
12336    if (Utilities.noString(parentType))
12337      t = parent;
12338    else {
12339      t = parent.predicate("fhir:"+parentType+'.'+name);
12340    }
12341    composeBackboneElement(t, "dateCriterion", name, element, index);
12342    if (element.hasCode()) {
12343      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "code", element.getCode(), -1);
12344    }
12345    if (element.hasValueElement()) {
12346      composeDateTime(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "value", element.getValueElement(), -1);
12347    }
12348  }
12349
12350  protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) {
12351    if (element == null) 
12352      return;
12353    Complex t;
12354    if (Utilities.noString(parentType))
12355      t = parent;
12356    else {
12357      t = parent.predicate("fhir:"+parentType+'.'+name);
12358    }
12359    composeDomainResource(t, "ImplementationGuide", name, element, index);
12360    if (element.hasUrlElement()) {
12361      composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1);
12362    }
12363    if (element.hasVersionElement()) {
12364      composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1);
12365    }
12366    if (element.hasNameElement()) {
12367      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
12368    }
12369    if (element.hasTitleElement()) {
12370      composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1);
12371    }
12372    if (element.hasStatusElement()) {
12373      composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1);
12374    }
12375    if (element.hasExperimentalElement()) {
12376      composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1);
12377    }
12378    if (element.hasDateElement()) {
12379      composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1);
12380    }
12381    if (element.hasPublisherElement()) {
12382      composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1);
12383    }
12384    for (int i = 0; i < element.getContact().size(); i++) {
12385      composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i);
12386    }
12387    if (element.hasDescriptionElement()) {
12388      composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
12389    }
12390    for (int i = 0; i < element.getUseContext().size(); i++) {
12391      composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i);
12392    }
12393    for (int i = 0; i < element.getJurisdiction().size(); i++) {
12394      composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i);
12395    }
12396    if (element.hasCopyrightElement()) {
12397      composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1);
12398    }
12399    if (element.hasPackageIdElement()) {
12400      composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1);
12401    }
12402    if (element.hasLicenseElement()) {
12403      composeEnum(t, "ImplementationGuide", "license", element.getLicenseElement(), -1);
12404    }
12405    for (int i = 0; i < element.getFhirVersion().size(); i++) {
12406      composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i);
12407    }
12408    for (int i = 0; i < element.getDependsOn().size(); i++) {
12409      composeImplementationGuideDependsOnComponent(t, "ImplementationGuide", "dependsOn", element.getDependsOn().get(i), i);
12410    }
12411    for (int i = 0; i < element.getGlobal().size(); i++) {
12412      composeImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i);
12413    }
12414    if (element.hasDefinition()) {
12415      composeImplementationGuideDefinitionComponent(t, "ImplementationGuide", "definition", element.getDefinition(), -1);
12416    }
12417    if (element.hasManifest()) {
12418      composeImplementationGuideManifestComponent(t, "ImplementationGuide", "manifest", element.getManifest(), -1);
12419    }
12420  }
12421
12422  protected void composeImplementationGuideDependsOnComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependsOnComponent element, int index) {
12423    if (element == null) 
12424      return;
12425    Complex t;
12426    if (Utilities.noString(parentType))
12427      t = parent;
12428    else {
12429      t = parent.predicate("fhir:"+parentType+'.'+name);
12430    }
12431    composeBackboneElement(t, "dependsOn", name, element, index);
12432    if (element.hasUriElement()) {
12433      composeCanonical(t, "ImplementationGuideDependsOnComponent", "uri", element.getUriElement(), -1);
12434    }
12435    if (element.hasPackageIdElement()) {
12436      composeId(t, "ImplementationGuideDependsOnComponent", "packageId", element.getPackageIdElement(), -1);
12437    }
12438    if (element.hasVersionElement()) {
12439      composeString(t, "ImplementationGuideDependsOnComponent", "version", element.getVersionElement(), -1);
12440    }
12441  }
12442
12443  protected void composeImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) {
12444    if (element == null) 
12445      return;
12446    Complex t;
12447    if (Utilities.noString(parentType))
12448      t = parent;
12449    else {
12450      t = parent.predicate("fhir:"+parentType+'.'+name);
12451    }
12452    composeBackboneElement(t, "global", name, element, index);
12453    if (element.hasTypeElement()) {
12454      composeCode(t, "ImplementationGuideGlobalComponent", "type", element.getTypeElement(), -1);
12455    }
12456    if (element.hasProfileElement()) {
12457      composeCanonical(t, "ImplementationGuideGlobalComponent", "profile", element.getProfileElement(), -1);
12458    }
12459  }
12460
12461  protected void composeImplementationGuideDefinitionComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionComponent element, int index) {
12462    if (element == null) 
12463      return;
12464    Complex t;
12465    if (Utilities.noString(parentType))
12466      t = parent;
12467    else {
12468      t = parent.predicate("fhir:"+parentType+'.'+name);
12469    }
12470    composeBackboneElement(t, "definition", name, element, index);
12471    for (int i = 0; i < element.getGrouping().size(); i++) {
12472      composeImplementationGuideDefinitionGroupingComponent(t, "ImplementationGuideDefinitionComponent", "grouping", element.getGrouping().get(i), i);
12473    }
12474    for (int i = 0; i < element.getResource().size(); i++) {
12475      composeImplementationGuideDefinitionResourceComponent(t, "ImplementationGuideDefinitionComponent", "resource", element.getResource().get(i), i);
12476    }
12477    if (element.hasPage()) {
12478      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionComponent", "page", element.getPage(), -1);
12479    }
12480    for (int i = 0; i < element.getParameter().size(); i++) {
12481      composeImplementationGuideDefinitionParameterComponent(t, "ImplementationGuideDefinitionComponent", "parameter", element.getParameter().get(i), i);
12482    }
12483    for (int i = 0; i < element.getTemplate().size(); i++) {
12484      composeImplementationGuideDefinitionTemplateComponent(t, "ImplementationGuideDefinitionComponent", "template", element.getTemplate().get(i), i);
12485    }
12486  }
12487
12488  protected void composeImplementationGuideDefinitionGroupingComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionGroupingComponent element, int index) {
12489    if (element == null) 
12490      return;
12491    Complex t;
12492    if (Utilities.noString(parentType))
12493      t = parent;
12494    else {
12495      t = parent.predicate("fhir:"+parentType+'.'+name);
12496    }
12497    composeBackboneElement(t, "grouping", name, element, index);
12498    if (element.hasNameElement()) {
12499      composeString(t, "ImplementationGuideDefinitionGroupingComponent", "name", element.getNameElement(), -1);
12500    }
12501    if (element.hasDescriptionElement()) {
12502      composeString(t, "ImplementationGuideDefinitionGroupingComponent", "description", element.getDescriptionElement(), -1);
12503    }
12504  }
12505
12506  protected void composeImplementationGuideDefinitionResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionResourceComponent element, int index) {
12507    if (element == null) 
12508      return;
12509    Complex t;
12510    if (Utilities.noString(parentType))
12511      t = parent;
12512    else {
12513      t = parent.predicate("fhir:"+parentType+'.'+name);
12514    }
12515    composeBackboneElement(t, "resource", name, element, index);
12516    if (element.hasReference()) {
12517      composeReference(t, "ImplementationGuideDefinitionResourceComponent", "reference", element.getReference(), -1);
12518    }
12519    for (int i = 0; i < element.getFhirVersion().size(); i++) {
12520      composeEnum(t, "ImplementationGuideDefinitionResourceComponent", "fhirVersion", element.getFhirVersion().get(i), i);
12521    }
12522    if (element.hasNameElement()) {
12523      composeString(t, "ImplementationGuideDefinitionResourceComponent", "name", element.getNameElement(), -1);
12524    }
12525    if (element.hasDescriptionElement()) {
12526      composeString(t, "ImplementationGuideDefinitionResourceComponent", "description", element.getDescriptionElement(), -1);
12527    }
12528    if (element.hasExample()) {
12529      composeType(t, "ImplementationGuideDefinitionResourceComponent", "example", element.getExample(), -1);
12530    }
12531    if (element.hasGroupingIdElement()) {
12532      composeId(t, "ImplementationGuideDefinitionResourceComponent", "groupingId", element.getGroupingIdElement(), -1);
12533    }
12534  }
12535
12536  protected void composeImplementationGuideDefinitionPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionPageComponent element, int index) {
12537    if (element == null) 
12538      return;
12539    Complex t;
12540    if (Utilities.noString(parentType))
12541      t = parent;
12542    else {
12543      t = parent.predicate("fhir:"+parentType+'.'+name);
12544    }
12545    composeBackboneElement(t, "page", name, element, index);
12546    if (element.hasName()) {
12547      composeType(t, "ImplementationGuideDefinitionPageComponent", "name", element.getName(), -1);
12548    }
12549    if (element.hasTitleElement()) {
12550      composeString(t, "ImplementationGuideDefinitionPageComponent", "title", element.getTitleElement(), -1);
12551    }
12552    if (element.hasGenerationElement()) {
12553      composeEnum(t, "ImplementationGuideDefinitionPageComponent", "generation", element.getGenerationElement(), -1);
12554    }
12555    for (int i = 0; i < element.getPage().size(); i++) {
12556      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionPageComponent", "page", element.getPage().get(i), i);
12557    }
12558  }
12559
12560  protected void composeImplementationGuideDefinitionParameterComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionParameterComponent element, int index) {
12561    if (element == null) 
12562      return;
12563    Complex t;
12564    if (Utilities.noString(parentType))
12565      t = parent;
12566    else {
12567      t = parent.predicate("fhir:"+parentType+'.'+name);
12568    }
12569    composeBackboneElement(t, "parameter", name, element, index);
12570    if (element.hasCodeElement()) {
12571      composeEnum(t, "ImplementationGuideDefinitionParameterComponent", "code", element.getCodeElement(), -1);
12572    }
12573    if (element.hasValueElement()) {
12574      composeString(t, "ImplementationGuideDefinitionParameterComponent", "value", element.getValueElement(), -1);
12575    }
12576  }
12577
12578  protected void composeImplementationGuideDefinitionTemplateComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionTemplateComponent element, int index) {
12579    if (element == null) 
12580      return;
12581    Complex t;
12582    if (Utilities.noString(parentType))
12583      t = parent;
12584    else {
12585      t = parent.predicate("fhir:"+parentType+'.'+name);
12586    }
12587    composeBackboneElement(t, "template", name, element, index);
12588    if (element.hasCodeElement()) {
12589      composeCode(t, "ImplementationGuideDefinitionTemplateComponent", "code", element.getCodeElement(), -1);
12590    }
12591    if (element.hasSourceElement()) {
12592      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "source", element.getSourceElement(), -1);
12593    }
12594    if (element.hasScopeElement()) {
12595      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "scope", element.getScopeElement(), -1);
12596    }
12597  }
12598
12599  protected void composeImplementationGuideManifestComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideManifestComponent element, int index) {
12600    if (element == null) 
12601      return;
12602    Complex t;
12603    if (Utilities.noString(parentType))
12604      t = parent;
12605    else {
12606      t = parent.predicate("fhir:"+parentType+'.'+name);
12607    }
12608    composeBackboneElement(t, "manifest", name, element, index);
12609    if (element.hasRenderingElement()) {
12610      composeUrl(t, "ImplementationGuideManifestComponent", "rendering", element.getRenderingElement(), -1);
12611    }
12612    for (int i = 0; i < element.getResource().size(); i++) {
12613      composeImplementationGuideManifestResourceComponent(t, "ImplementationGuideManifestComponent", "resource", element.getResource().get(i), i);
12614    }
12615    for (int i = 0; i < element.getPage().size(); i++) {
12616      composeImplementationGuideManifestPageComponent(t, "ImplementationGuideManifestComponent", "page", element.getPage().get(i), i);
12617    }
12618    for (int i = 0; i < element.getImage().size(); i++) {
12619      composeString(t, "ImplementationGuideManifestComponent", "image", element.getImage().get(i), i);
12620    }
12621    for (int i = 0; i < element.getOther().size(); i++) {
12622      composeString(t, "ImplementationGuideManifestComponent", "other", element.getOther().get(i), i);
12623    }
12624  }
12625
12626  protected void composeImplementationGuideManifestResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestResourceComponent element, int index) {
12627    if (element == null) 
12628      return;
12629    Complex t;
12630    if (Utilities.noString(parentType))
12631      t = parent;
12632    else {
12633      t = parent.predicate("fhir:"+parentType+'.'+name);
12634    }
12635    composeBackboneElement(t, "resource", name, element, index);
12636    if (element.hasReference()) {
12637      composeReference(t, "ManifestResourceComponent", "reference", element.getReference(), -1);
12638    }
12639    if (element.hasExample()) {
12640      composeType(t, "ManifestResourceComponent", "example", element.getExample(), -1);
12641    }
12642    if (element.hasRelativePathElement()) {
12643      composeUrl(t, "ManifestResourceComponent", "relativePath", element.getRelativePathElement(), -1);
12644    }
12645  }
12646
12647  protected void composeImplementationGuideManifestPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestPageComponent element, int index) {
12648    if (element == null) 
12649      return;
12650    Complex t;
12651    if (Utilities.noString(parentType))
12652      t = parent;
12653    else {
12654      t = parent.predicate("fhir:"+parentType+'.'+name);
12655    }
12656    composeBackboneElement(t, "page", name, element, index);
12657    if (element.hasNameElement()) {
12658      composeString(t, "ManifestPageComponent", "name", element.getNameElement(), -1);
12659    }
12660    if (element.hasTitleElement()) {
12661      composeString(t, "ManifestPageComponent", "title", element.getTitleElement(), -1);
12662    }
12663    for (int i = 0; i < element.getAnchor().size(); i++) {
12664      composeString(t, "ManifestPageComponent", "anchor", element.getAnchor().get(i), i);
12665    }
12666  }
12667
12668  protected void composeIngredient(Complex parent, String parentType, String name, Ingredient element, int index) {
12669    if (element == null) 
12670      return;
12671    Complex t;
12672    if (Utilities.noString(parentType))
12673      t = parent;
12674    else {
12675      t = parent.predicate("fhir:"+parentType+'.'+name);
12676    }
12677    composeDomainResource(t, "Ingredient", name, element, index);
12678    if (element.hasIdentifier()) {
12679      composeIdentifier(t, "Ingredient", "identifier", element.getIdentifier(), -1);
12680    }
12681    if (element.hasStatusElement()) {
12682      composeEnum(t, "Ingredient", "status", element.getStatusElement(), -1);
12683    }
12684    for (int i = 0; i < element.getFor().size(); i++) {
12685      composeReference(t, "Ingredient", "for", element.getFor().get(i), i);
12686    }
12687    if (element.hasRole()) {
12688      composeCodeableConcept(t, "Ingredient", "role", element.getRole(), -1);
12689    }
12690    for (int i = 0; i < element.getFunction().size(); i++) {
12691      composeCodeableConcept(t, "Ingredient", "function", element.getFunction().get(i), i);
12692    }
12693    if (element.hasAllergenicIndicatorElement()) {
12694      composeBoolean(t, "Ingredient", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
12695    }
12696    for (int i = 0; i < element.getManufacturer().size(); i++) {
12697      composeIngredientManufacturerComponent(t, "Ingredient", "manufacturer", element.getManufacturer().get(i), i);
12698    }
12699    if (element.hasSubstance()) {
12700      composeIngredientSubstanceComponent(t, "Ingredient", "substance", element.getSubstance(), -1);
12701    }
12702  }
12703
12704  protected void composeIngredientManufacturerComponent(Complex parent, String parentType, String name, Ingredient.IngredientManufacturerComponent element, int index) {
12705    if (element == null) 
12706      return;
12707    Complex t;
12708    if (Utilities.noString(parentType))
12709      t = parent;
12710    else {
12711      t = parent.predicate("fhir:"+parentType+'.'+name);
12712    }
12713    composeBackboneElement(t, "manufacturer", name, element, index);
12714    if (element.hasRole()) {
12715      composeCoding(t, "IngredientManufacturerComponent", "role", element.getRole(), -1);
12716    }
12717    if (element.hasManufacturer()) {
12718      composeReference(t, "IngredientManufacturerComponent", "manufacturer", element.getManufacturer(), -1);
12719    }
12720  }
12721
12722  protected void composeIngredientSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceComponent element, int index) {
12723    if (element == null) 
12724      return;
12725    Complex t;
12726    if (Utilities.noString(parentType))
12727      t = parent;
12728    else {
12729      t = parent.predicate("fhir:"+parentType+'.'+name);
12730    }
12731    composeBackboneElement(t, "substance", name, element, index);
12732    if (element.hasCode()) {
12733      composeCodeableReference(t, "IngredientSubstanceComponent", "code", element.getCode(), -1);
12734    }
12735    for (int i = 0; i < element.getStrength().size(); i++) {
12736      composeIngredientSubstanceStrengthComponent(t, "IngredientSubstanceComponent", "strength", element.getStrength().get(i), i);
12737    }
12738  }
12739
12740  protected void composeIngredientSubstanceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceStrengthComponent element, int index) {
12741    if (element == null) 
12742      return;
12743    Complex t;
12744    if (Utilities.noString(parentType))
12745      t = parent;
12746    else {
12747      t = parent.predicate("fhir:"+parentType+'.'+name);
12748    }
12749    composeBackboneElement(t, "strength", name, element, index);
12750    if (element.hasPresentation()) {
12751      composeType(t, "IngredientSubstanceStrengthComponent", "presentation", element.getPresentation(), -1);
12752    }
12753    if (element.hasPresentationTextElement()) {
12754      composeString(t, "IngredientSubstanceStrengthComponent", "presentationText", element.getPresentationTextElement(), -1);
12755    }
12756    if (element.hasConcentration()) {
12757      composeType(t, "IngredientSubstanceStrengthComponent", "concentration", element.getConcentration(), -1);
12758    }
12759    if (element.hasConcentrationTextElement()) {
12760      composeString(t, "IngredientSubstanceStrengthComponent", "concentrationText", element.getConcentrationTextElement(), -1);
12761    }
12762    if (element.hasMeasurementPointElement()) {
12763      composeString(t, "IngredientSubstanceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
12764    }
12765    for (int i = 0; i < element.getCountry().size(); i++) {
12766      composeCodeableConcept(t, "IngredientSubstanceStrengthComponent", "country", element.getCountry().get(i), i);
12767    }
12768    for (int i = 0; i < element.getReferenceStrength().size(); i++) {
12769      composeIngredientSubstanceStrengthReferenceStrengthComponent(t, "IngredientSubstanceStrengthComponent", "referenceStrength", element.getReferenceStrength().get(i), i);
12770    }
12771  }
12772
12773  protected void composeIngredientSubstanceStrengthReferenceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceStrengthReferenceStrengthComponent element, int index) {
12774    if (element == null) 
12775      return;
12776    Complex t;
12777    if (Utilities.noString(parentType))
12778      t = parent;
12779    else {
12780      t = parent.predicate("fhir:"+parentType+'.'+name);
12781    }
12782    composeBackboneElement(t, "referenceStrength", name, element, index);
12783    if (element.hasSubstance()) {
12784      composeCodeableReference(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "substance", element.getSubstance(), -1);
12785    }
12786    if (element.hasStrength()) {
12787      composeType(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "strength", element.getStrength(), -1);
12788    }
12789    if (element.hasMeasurementPointElement()) {
12790      composeString(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
12791    }
12792    for (int i = 0; i < element.getCountry().size(); i++) {
12793      composeCodeableConcept(t, "IngredientSubstanceStrengthReferenceStrengthComponent", "country", element.getCountry().get(i), i);
12794    }
12795  }
12796
12797  protected void composeInsurancePlan(Complex parent, String parentType, String name, InsurancePlan element, int index) {
12798    if (element == null) 
12799      return;
12800    Complex t;
12801    if (Utilities.noString(parentType))
12802      t = parent;
12803    else {
12804      t = parent.predicate("fhir:"+parentType+'.'+name);
12805    }
12806    composeDomainResource(t, "InsurancePlan", name, element, index);
12807    for (int i = 0; i < element.getIdentifier().size(); i++) {
12808      composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i);
12809    }
12810    if (element.hasStatusElement()) {
12811      composeEnum(t, "InsurancePlan", "status", element.getStatusElement(), -1);
12812    }
12813    for (int i = 0; i < element.getType().size(); i++) {
12814      composeCodeableConcept(t, "InsurancePlan", "type", element.getType().get(i), i);
12815    }
12816    if (element.hasNameElement()) {
12817      composeString(t, "InsurancePlan", "name", element.getNameElement(), -1);
12818    }
12819    for (int i = 0; i < element.getAlias().size(); i++) {
12820      composeString(t, "InsurancePlan", "alias", element.getAlias().get(i), i);
12821    }
12822    if (element.hasPeriod()) {
12823      composePeriod(t, "InsurancePlan", "period", element.getPeriod(), -1);
12824    }
12825    if (element.hasOwnedBy()) {
12826      composeReference(t, "InsurancePlan", "ownedBy", element.getOwnedBy(), -1);
12827    }
12828    if (element.hasAdministeredBy()) {
12829      composeReference(t, "InsurancePlan", "administeredBy", element.getAdministeredBy(), -1);
12830    }
12831    for (int i = 0; i < element.getCoverageArea().size(); i++) {
12832      composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i);
12833    }
12834    for (int i = 0; i < element.getContact().size(); i++) {
12835      composeInsurancePlanContactComponent(t, "InsurancePlan", "contact", element.getContact().get(i), i);
12836    }
12837    for (int i = 0; i < element.getEndpoint().size(); i++) {
12838      composeReference(t, "InsurancePlan", "endpoint", element.getEndpoint().get(i), i);
12839    }
12840    for (int i = 0; i < element.getNetwork().size(); i++) {
12841      composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i);
12842    }
12843    for (int i = 0; i < element.getCoverage().size(); i++) {
12844      composeInsurancePlanCoverageComponent(t, "InsurancePlan", "coverage", element.getCoverage().get(i), i);
12845    }
12846    for (int i = 0; i < element.getPlan().size(); i++) {
12847      composeInsurancePlanPlanComponent(t, "InsurancePlan", "plan", element.getPlan().get(i), i);
12848    }
12849  }
12850
12851  protected void composeInsurancePlanContactComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanContactComponent element, int index) {
12852    if (element == null) 
12853      return;
12854    Complex t;
12855    if (Utilities.noString(parentType))
12856      t = parent;
12857    else {
12858      t = parent.predicate("fhir:"+parentType+'.'+name);
12859    }
12860    composeBackboneElement(t, "contact", name, element, index);
12861    if (element.hasPurpose()) {
12862      composeCodeableConcept(t, "InsurancePlanContactComponent", "purpose", element.getPurpose(), -1);
12863    }
12864    if (element.hasName()) {
12865      composeHumanName(t, "InsurancePlanContactComponent", "name", element.getName(), -1);
12866    }
12867    for (int i = 0; i < element.getTelecom().size(); i++) {
12868      composeContactPoint(t, "InsurancePlanContactComponent", "telecom", element.getTelecom().get(i), i);
12869    }
12870    if (element.hasAddress()) {
12871      composeAddress(t, "InsurancePlanContactComponent", "address", element.getAddress(), -1);
12872    }
12873  }
12874
12875  protected void composeInsurancePlanCoverageComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanCoverageComponent element, int index) {
12876    if (element == null) 
12877      return;
12878    Complex t;
12879    if (Utilities.noString(parentType))
12880      t = parent;
12881    else {
12882      t = parent.predicate("fhir:"+parentType+'.'+name);
12883    }
12884    composeBackboneElement(t, "coverage", name, element, index);
12885    if (element.hasType()) {
12886      composeCodeableConcept(t, "InsurancePlanCoverageComponent", "type", element.getType(), -1);
12887    }
12888    for (int i = 0; i < element.getNetwork().size(); i++) {
12889      composeReference(t, "InsurancePlanCoverageComponent", "network", element.getNetwork().get(i), i);
12890    }
12891    for (int i = 0; i < element.getBenefit().size(); i++) {
12892      composeInsurancePlanCoverageBenefitComponent(t, "InsurancePlanCoverageComponent", "benefit", element.getBenefit().get(i), i);
12893    }
12894  }
12895
12896  protected void composeInsurancePlanCoverageBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitComponent element, int index) {
12897    if (element == null) 
12898      return;
12899    Complex t;
12900    if (Utilities.noString(parentType))
12901      t = parent;
12902    else {
12903      t = parent.predicate("fhir:"+parentType+'.'+name);
12904    }
12905    composeBackboneElement(t, "benefit", name, element, index);
12906    if (element.hasType()) {
12907      composeCodeableConcept(t, "CoverageBenefitComponent", "type", element.getType(), -1);
12908    }
12909    if (element.hasRequirementElement()) {
12910      composeString(t, "CoverageBenefitComponent", "requirement", element.getRequirementElement(), -1);
12911    }
12912    for (int i = 0; i < element.getLimit().size(); i++) {
12913      composeInsurancePlanCoverageBenefitLimitComponent(t, "CoverageBenefitComponent", "limit", element.getLimit().get(i), i);
12914    }
12915  }
12916
12917  protected void composeInsurancePlanCoverageBenefitLimitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitLimitComponent element, int index) {
12918    if (element == null) 
12919      return;
12920    Complex t;
12921    if (Utilities.noString(parentType))
12922      t = parent;
12923    else {
12924      t = parent.predicate("fhir:"+parentType+'.'+name);
12925    }
12926    composeBackboneElement(t, "limit", name, element, index);
12927    if (element.hasValue()) {
12928      composeQuantity(t, "CoverageBenefitLimitComponent", "value", element.getValue(), -1);
12929    }
12930    if (element.hasCode()) {
12931      composeCodeableConcept(t, "CoverageBenefitLimitComponent", "code", element.getCode(), -1);
12932    }
12933  }
12934
12935  protected void composeInsurancePlanPlanComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanComponent element, int index) {
12936    if (element == null) 
12937      return;
12938    Complex t;
12939    if (Utilities.noString(parentType))
12940      t = parent;
12941    else {
12942      t = parent.predicate("fhir:"+parentType+'.'+name);
12943    }
12944    composeBackboneElement(t, "plan", name, element, index);
12945    for (int i = 0; i < element.getIdentifier().size(); i++) {
12946      composeIdentifier(t, "InsurancePlanPlanComponent", "identifier", element.getIdentifier().get(i), i);
12947    }
12948    if (element.hasType()) {
12949      composeCodeableConcept(t, "InsurancePlanPlanComponent", "type", element.getType(), -1);
12950    }
12951    for (int i = 0; i < element.getCoverageArea().size(); i++) {
12952      composeReference(t, "InsurancePlanPlanComponent", "coverageArea", element.getCoverageArea().get(i), i);
12953    }
12954    for (int i = 0; i < element.getNetwork().size(); i++) {
12955      composeReference(t, "InsurancePlanPlanComponent", "network", element.getNetwork().get(i), i);
12956    }
12957    for (int i = 0; i < element.getGeneralCost().size(); i++) {
12958      composeInsurancePlanPlanGeneralCostComponent(t, "InsurancePlanPlanComponent", "generalCost", element.getGeneralCost().get(i), i);
12959    }
12960    for (int i = 0; i < element.getSpecificCost().size(); i++) {
12961      composeInsurancePlanPlanSpecificCostComponent(t, "InsurancePlanPlanComponent", "specificCost", element.getSpecificCost().get(i), i);
12962    }
12963  }
12964
12965  protected void composeInsurancePlanPlanGeneralCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanGeneralCostComponent element, int index) {
12966    if (element == null) 
12967      return;
12968    Complex t;
12969    if (Utilities.noString(parentType))
12970      t = parent;
12971    else {
12972      t = parent.predicate("fhir:"+parentType+'.'+name);
12973    }
12974    composeBackboneElement(t, "generalCost", name, element, index);
12975    if (element.hasType()) {
12976      composeCodeableConcept(t, "InsurancePlanPlanGeneralCostComponent", "type", element.getType(), -1);
12977    }
12978    if (element.hasGroupSizeElement()) {
12979      composePositiveInt(t, "InsurancePlanPlanGeneralCostComponent", "groupSize", element.getGroupSizeElement(), -1);
12980    }
12981    if (element.hasCost()) {
12982      composeMoney(t, "InsurancePlanPlanGeneralCostComponent", "cost", element.getCost(), -1);
12983    }
12984    if (element.hasCommentElement()) {
12985      composeString(t, "InsurancePlanPlanGeneralCostComponent", "comment", element.getCommentElement(), -1);
12986    }
12987  }
12988
12989  protected void composeInsurancePlanPlanSpecificCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanSpecificCostComponent element, int index) {
12990    if (element == null) 
12991      return;
12992    Complex t;
12993    if (Utilities.noString(parentType))
12994      t = parent;
12995    else {
12996      t = parent.predicate("fhir:"+parentType+'.'+name);
12997    }
12998    composeBackboneElement(t, "specificCost", name, element, index);
12999    if (element.hasCategory()) {
13000      composeCodeableConcept(t, "InsurancePlanPlanSpecificCostComponent", "category", element.getCategory(), -1);
13001    }
13002    for (int i = 0; i < element.getBenefit().size(); i++) {
13003      composeInsurancePlanPlanBenefitComponent(t, "InsurancePlanPlanSpecificCostComponent", "benefit", element.getBenefit().get(i), i);
13004    }
13005  }
13006
13007  protected void composeInsurancePlanPlanBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitComponent element, int index) {
13008    if (element == null) 
13009      return;
13010    Complex t;
13011    if (Utilities.noString(parentType))
13012      t = parent;
13013    else {
13014      t = parent.predicate("fhir:"+parentType+'.'+name);
13015    }
13016    composeBackboneElement(t, "benefit", name, element, index);
13017    if (element.hasType()) {
13018      composeCodeableConcept(t, "PlanBenefitComponent", "type", element.getType(), -1);
13019    }
13020    for (int i = 0; i < element.getCost().size(); i++) {
13021      composeInsurancePlanPlanBenefitCostComponent(t, "PlanBenefitComponent", "cost", element.getCost().get(i), i);
13022    }
13023  }
13024
13025  protected void composeInsurancePlanPlanBenefitCostComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitCostComponent element, int index) {
13026    if (element == null) 
13027      return;
13028    Complex t;
13029    if (Utilities.noString(parentType))
13030      t = parent;
13031    else {
13032      t = parent.predicate("fhir:"+parentType+'.'+name);
13033    }
13034    composeBackboneElement(t, "cost", name, element, index);
13035    if (element.hasType()) {
13036      composeCodeableConcept(t, "PlanBenefitCostComponent", "type", element.getType(), -1);
13037    }
13038    if (element.hasApplicability()) {
13039      composeCodeableConcept(t, "PlanBenefitCostComponent", "applicability", element.getApplicability(), -1);
13040    }
13041    for (int i = 0; i < element.getQualifiers().size(); i++) {
13042      composeCodeableConcept(t, "PlanBenefitCostComponent", "qualifiers", element.getQualifiers().get(i), i);
13043    }
13044    if (element.hasValue()) {
13045      composeQuantity(t, "PlanBenefitCostComponent", "value", element.getValue(), -1);
13046    }
13047  }
13048
13049  protected void composeInvoice(Complex parent, String parentType, String name, Invoice element, int index) {
13050    if (element == null) 
13051      return;
13052    Complex t;
13053    if (Utilities.noString(parentType))
13054      t = parent;
13055    else {
13056      t = parent.predicate("fhir:"+parentType+'.'+name);
13057    }
13058    composeDomainResource(t, "Invoice", name, element, index);
13059    for (int i = 0; i < element.getIdentifier().size(); i++) {
13060      composeIdentifier(t, "Invoice", "identifier", element.getIdentifier().get(i), i);
13061    }
13062    if (element.hasStatusElement()) {
13063      composeEnum(t, "Invoice", "status", element.getStatusElement(), -1);
13064    }
13065    if (element.hasCancelledReasonElement()) {
13066      composeString(t, "Invoice", "cancelledReason", element.getCancelledReasonElement(), -1);
13067    }
13068    if (element.hasType()) {
13069      composeCodeableConcept(t, "Invoice", "type", element.getType(), -1);
13070    }
13071    if (element.hasSubject()) {
13072      composeReference(t, "Invoice", "subject", element.getSubject(), -1);
13073    }
13074    if (element.hasRecipient()) {
13075      composeReference(t, "Invoice", "recipient", element.getRecipient(), -1);
13076    }
13077    if (element.hasDateElement()) {
13078      composeDateTime(t, "Invoice", "date", element.getDateElement(), -1);
13079    }
13080    for (int i = 0; i < element.getParticipant().size(); i++) {
13081      composeInvoiceParticipantComponent(t, "Invoice", "participant", element.getParticipant().get(i), i);
13082    }
13083    if (element.hasIssuer()) {
13084      composeReference(t, "Invoice", "issuer", element.getIssuer(), -1);
13085    }
13086    if (element.hasAccount()) {
13087      composeReference(t, "Invoice", "account", element.getAccount(), -1);
13088    }
13089    for (int i = 0; i < element.getLineItem().size(); i++) {
13090      composeInvoiceLineItemComponent(t, "Invoice", "lineItem", element.getLineItem().get(i), i);
13091    }
13092    for (int i = 0; i < element.getTotalPriceComponent().size(); i++) {
13093      composeInvoiceLineItemPriceComponentComponent(t, "Invoice", "totalPriceComponent", element.getTotalPriceComponent().get(i), i);
13094    }
13095    if (element.hasTotalNet()) {
13096      composeMoney(t, "Invoice", "totalNet", element.getTotalNet(), -1);
13097    }
13098    if (element.hasTotalGross()) {
13099      composeMoney(t, "Invoice", "totalGross", element.getTotalGross(), -1);
13100    }
13101    if (element.hasPaymentTermsElement()) {
13102      composeMarkdown(t, "Invoice", "paymentTerms", element.getPaymentTermsElement(), -1);
13103    }
13104    for (int i = 0; i < element.getNote().size(); i++) {
13105      composeAnnotation(t, "Invoice", "note", element.getNote().get(i), i);
13106    }
13107  }
13108
13109  protected void composeInvoiceParticipantComponent(Complex parent, String parentType, String name, Invoice.InvoiceParticipantComponent element, int index) {
13110    if (element == null) 
13111      return;
13112    Complex t;
13113    if (Utilities.noString(parentType))
13114      t = parent;
13115    else {
13116      t = parent.predicate("fhir:"+parentType+'.'+name);
13117    }
13118    composeBackboneElement(t, "participant", name, element, index);
13119    if (element.hasRole()) {
13120      composeCodeableConcept(t, "InvoiceParticipantComponent", "role", element.getRole(), -1);
13121    }
13122    if (element.hasActor()) {
13123      composeReference(t, "InvoiceParticipantComponent", "actor", element.getActor(), -1);
13124    }
13125  }
13126
13127  protected void composeInvoiceLineItemComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemComponent element, int index) {
13128    if (element == null) 
13129      return;
13130    Complex t;
13131    if (Utilities.noString(parentType))
13132      t = parent;
13133    else {
13134      t = parent.predicate("fhir:"+parentType+'.'+name);
13135    }
13136    composeBackboneElement(t, "lineItem", name, element, index);
13137    if (element.hasSequenceElement()) {
13138      composePositiveInt(t, "InvoiceLineItemComponent", "sequence", element.getSequenceElement(), -1);
13139    }
13140    if (element.hasChargeItem()) {
13141      composeType(t, "InvoiceLineItemComponent", "chargeItem", element.getChargeItem(), -1);
13142    }
13143    for (int i = 0; i < element.getPriceComponent().size(); i++) {
13144      composeInvoiceLineItemPriceComponentComponent(t, "InvoiceLineItemComponent", "priceComponent", element.getPriceComponent().get(i), i);
13145    }
13146  }
13147
13148  protected void composeInvoiceLineItemPriceComponentComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemPriceComponentComponent element, int index) {
13149    if (element == null) 
13150      return;
13151    Complex t;
13152    if (Utilities.noString(parentType))
13153      t = parent;
13154    else {
13155      t = parent.predicate("fhir:"+parentType+'.'+name);
13156    }
13157    composeBackboneElement(t, "priceComponent", name, element, index);
13158    if (element.hasTypeElement()) {
13159      composeEnum(t, "InvoiceLineItemPriceComponentComponent", "type", element.getTypeElement(), -1);
13160    }
13161    if (element.hasCode()) {
13162      composeCodeableConcept(t, "InvoiceLineItemPriceComponentComponent", "code", element.getCode(), -1);
13163    }
13164    if (element.hasFactorElement()) {
13165      composeDecimal(t, "InvoiceLineItemPriceComponentComponent", "factor", element.getFactorElement(), -1);
13166    }
13167    if (element.hasAmount()) {
13168      composeMoney(t, "InvoiceLineItemPriceComponentComponent", "amount", element.getAmount(), -1);
13169    }
13170  }
13171
13172  protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) {
13173    if (element == null) 
13174      return;
13175    Complex t;
13176    if (Utilities.noString(parentType))
13177      t = parent;
13178    else {
13179      t = parent.predicate("fhir:"+parentType+'.'+name);
13180    }
13181    composeDomainResource(t, "Library", name, element, index);
13182    if (element.hasUrlElement()) {
13183      composeUri(t, "Library", "url", element.getUrlElement(), -1);
13184    }
13185    for (int i = 0; i < element.getIdentifier().size(); i++) {
13186      composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i);
13187    }
13188    if (element.hasVersionElement()) {
13189      composeString(t, "Library", "version", element.getVersionElement(), -1);
13190    }
13191    if (element.hasNameElement()) {
13192      composeString(t, "Library", "name", element.getNameElement(), -1);
13193    }
13194    if (element.hasTitleElement()) {
13195      composeString(t, "Library", "title", element.getTitleElement(), -1);
13196    }
13197    if (element.hasSubtitleElement()) {
13198      composeString(t, "Library", "subtitle", element.getSubtitleElement(), -1);
13199    }
13200    if (element.hasStatusElement()) {
13201      composeEnum(t, "Library", "status", element.getStatusElement(), -1);
13202    }
13203    if (element.hasExperimentalElement()) {
13204      composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1);
13205    }
13206    if (element.hasType()) {
13207      composeCodeableConcept(t, "Library", "type", element.getType(), -1);
13208    }
13209    if (element.hasSubject()) {
13210      composeType(t, "Library", "subject", element.getSubject(), -1);
13211    }
13212    if (element.hasDateElement()) {
13213      composeDateTime(t, "Library", "date", element.getDateElement(), -1);
13214    }
13215    if (element.hasPublisherElement()) {
13216      composeString(t, "Library", "publisher", element.getPublisherElement(), -1);
13217    }
13218    for (int i = 0; i < element.getContact().size(); i++) {
13219      composeContactDetail(t, "Library", "contact", element.getContact().get(i), i);
13220    }
13221    if (element.hasDescriptionElement()) {
13222      composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1);
13223    }
13224    for (int i = 0; i < element.getUseContext().size(); i++) {
13225      composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i);
13226    }
13227    for (int i = 0; i < element.getJurisdiction().size(); i++) {
13228      composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i);
13229    }
13230    if (element.hasPurposeElement()) {
13231      composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1);
13232    }
13233    if (element.hasUsageElement()) {
13234      composeString(t, "Library", "usage", element.getUsageElement(), -1);
13235    }
13236    if (element.hasCopyrightElement()) {
13237      composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1);
13238    }
13239    if (element.hasApprovalDateElement()) {
13240      composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1);
13241    }
13242    if (element.hasLastReviewDateElement()) {
13243      composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1);
13244    }
13245    if (element.hasEffectivePeriod()) {
13246      composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1);
13247    }
13248    for (int i = 0; i < element.getTopic().size(); i++) {
13249      composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i);
13250    }
13251    for (int i = 0; i < element.getAuthor().size(); i++) {
13252      composeContactDetail(t, "Library", "author", element.getAuthor().get(i), i);
13253    }
13254    for (int i = 0; i < element.getEditor().size(); i++) {
13255      composeContactDetail(t, "Library", "editor", element.getEditor().get(i), i);
13256    }
13257    for (int i = 0; i < element.getReviewer().size(); i++) {
13258      composeContactDetail(t, "Library", "reviewer", element.getReviewer().get(i), i);
13259    }
13260    for (int i = 0; i < element.getEndorser().size(); i++) {
13261      composeContactDetail(t, "Library", "endorser", element.getEndorser().get(i), i);
13262    }
13263    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
13264      composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i);
13265    }
13266    for (int i = 0; i < element.getParameter().size(); i++) {
13267      composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i);
13268    }
13269    for (int i = 0; i < element.getDataRequirement().size(); i++) {
13270      composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i);
13271    }
13272    for (int i = 0; i < element.getContent().size(); i++) {
13273      composeAttachment(t, "Library", "content", element.getContent().get(i), i);
13274    }
13275  }
13276
13277  protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) {
13278    if (element == null) 
13279      return;
13280    Complex t;
13281    if (Utilities.noString(parentType))
13282      t = parent;
13283    else {
13284      t = parent.predicate("fhir:"+parentType+'.'+name);
13285    }
13286    composeDomainResource(t, "Linkage", name, element, index);
13287    if (element.hasActiveElement()) {
13288      composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1);
13289    }
13290    if (element.hasAuthor()) {
13291      composeReference(t, "Linkage", "author", element.getAuthor(), -1);
13292    }
13293    for (int i = 0; i < element.getItem().size(); i++) {
13294      composeLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i);
13295    }
13296  }
13297
13298  protected void composeLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) {
13299    if (element == null) 
13300      return;
13301    Complex t;
13302    if (Utilities.noString(parentType))
13303      t = parent;
13304    else {
13305      t = parent.predicate("fhir:"+parentType+'.'+name);
13306    }
13307    composeBackboneElement(t, "item", name, element, index);
13308    if (element.hasTypeElement()) {
13309      composeEnum(t, "LinkageItemComponent", "type", element.getTypeElement(), -1);
13310    }
13311    if (element.hasResource()) {
13312      composeReference(t, "LinkageItemComponent", "resource", element.getResource(), -1);
13313    }
13314  }
13315
13316  protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) {
13317    if (element == null) 
13318      return;
13319    Complex t;
13320    if (Utilities.noString(parentType))
13321      t = parent;
13322    else {
13323      t = parent.predicate("fhir:"+parentType+'.'+name);
13324    }
13325    composeDomainResource(t, "List", name, element, index);
13326    for (int i = 0; i < element.getIdentifier().size(); i++) {
13327      composeIdentifier(t, "ListResource", "identifier", element.getIdentifier().get(i), i);
13328    }
13329    if (element.hasStatusElement()) {
13330      composeEnum(t, "ListResource", "status", element.getStatusElement(), -1);
13331    }
13332    if (element.hasModeElement()) {
13333      composeEnum(t, "ListResource", "mode", element.getModeElement(), -1);
13334    }
13335    if (element.hasTitleElement()) {
13336      composeString(t, "ListResource", "title", element.getTitleElement(), -1);
13337    }
13338    if (element.hasCode()) {
13339      composeCodeableConcept(t, "ListResource", "code", element.getCode(), -1);
13340    }
13341    if (element.hasSubject()) {
13342      composeReference(t, "ListResource", "subject", element.getSubject(), -1);
13343    }
13344    if (element.hasEncounter()) {
13345      composeReference(t, "ListResource", "encounter", element.getEncounter(), -1);
13346    }
13347    if (element.hasDateElement()) {
13348      composeDateTime(t, "ListResource", "date", element.getDateElement(), -1);
13349    }
13350    if (element.hasSource()) {
13351      composeReference(t, "ListResource", "source", element.getSource(), -1);
13352    }
13353    if (element.hasOrderedBy()) {
13354      composeCodeableConcept(t, "ListResource", "orderedBy", element.getOrderedBy(), -1);
13355    }
13356    for (int i = 0; i < element.getNote().size(); i++) {
13357      composeAnnotation(t, "ListResource", "note", element.getNote().get(i), i);
13358    }
13359    for (int i = 0; i < element.getEntry().size(); i++) {
13360      composeListResourceEntryComponent(t, "ListResource", "entry", element.getEntry().get(i), i);
13361    }
13362    if (element.hasEmptyReason()) {
13363      composeCodeableConcept(t, "ListResource", "emptyReason", element.getEmptyReason(), -1);
13364    }
13365  }
13366
13367  protected void composeListResourceEntryComponent(Complex parent, String parentType, String name, ListResource.ListResourceEntryComponent element, int index) {
13368    if (element == null) 
13369      return;
13370    Complex t;
13371    if (Utilities.noString(parentType))
13372      t = parent;
13373    else {
13374      t = parent.predicate("fhir:"+parentType+'.'+name);
13375    }
13376    composeBackboneElement(t, "entry", name, element, index);
13377    if (element.hasFlag()) {
13378      composeCodeableConcept(t, "ListResourceEntryComponent", "flag", element.getFlag(), -1);
13379    }
13380    if (element.hasDeletedElement()) {
13381      composeBoolean(t, "ListResourceEntryComponent", "deleted", element.getDeletedElement(), -1);
13382    }
13383    if (element.hasDateElement()) {
13384      composeDateTime(t, "ListResourceEntryComponent", "date", element.getDateElement(), -1);
13385    }
13386    if (element.hasItem()) {
13387      composeReference(t, "ListResourceEntryComponent", "item", element.getItem(), -1);
13388    }
13389  }
13390
13391  protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) {
13392    if (element == null) 
13393      return;
13394    Complex t;
13395    if (Utilities.noString(parentType))
13396      t = parent;
13397    else {
13398      t = parent.predicate("fhir:"+parentType+'.'+name);
13399    }
13400    composeDomainResource(t, "Location", name, element, index);
13401    for (int i = 0; i < element.getIdentifier().size(); i++) {
13402      composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i);
13403    }
13404    if (element.hasStatusElement()) {
13405      composeEnum(t, "Location", "status", element.getStatusElement(), -1);
13406    }
13407    if (element.hasOperationalStatus()) {
13408      composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1);
13409    }
13410    if (element.hasNameElement()) {
13411      composeString(t, "Location", "name", element.getNameElement(), -1);
13412    }
13413    for (int i = 0; i < element.getAlias().size(); i++) {
13414      composeString(t, "Location", "alias", element.getAlias().get(i), i);
13415    }
13416    if (element.hasDescriptionElement()) {
13417      composeString(t, "Location", "description", element.getDescriptionElement(), -1);
13418    }
13419    if (element.hasModeElement()) {
13420      composeEnum(t, "Location", "mode", element.getModeElement(), -1);
13421    }
13422    for (int i = 0; i < element.getType().size(); i++) {
13423      composeCodeableConcept(t, "Location", "type", element.getType().get(i), i);
13424    }
13425    for (int i = 0; i < element.getTelecom().size(); i++) {
13426      composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i);
13427    }
13428    if (element.hasAddress()) {
13429      composeAddress(t, "Location", "address", element.getAddress(), -1);
13430    }
13431    if (element.hasPhysicalType()) {
13432      composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1);
13433    }
13434    if (element.hasPosition()) {
13435      composeLocationPositionComponent(t, "Location", "position", element.getPosition(), -1);
13436    }
13437    if (element.hasManagingOrganization()) {
13438      composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1);
13439    }
13440    if (element.hasPartOf()) {
13441      composeReference(t, "Location", "partOf", element.getPartOf(), -1);
13442    }
13443    for (int i = 0; i < element.getHoursOfOperation().size(); i++) {
13444      composeLocationHoursOfOperationComponent(t, "Location", "hoursOfOperation", element.getHoursOfOperation().get(i), i);
13445    }
13446    if (element.hasAvailabilityExceptionsElement()) {
13447      composeString(t, "Location", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
13448    }
13449    for (int i = 0; i < element.getEndpoint().size(); i++) {
13450      composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i);
13451    }
13452  }
13453
13454  protected void composeLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) {
13455    if (element == null) 
13456      return;
13457    Complex t;
13458    if (Utilities.noString(parentType))
13459      t = parent;
13460    else {
13461      t = parent.predicate("fhir:"+parentType+'.'+name);
13462    }
13463    composeBackboneElement(t, "position", name, element, index);
13464    if (element.hasLongitudeElement()) {
13465      composeDecimal(t, "LocationPositionComponent", "longitude", element.getLongitudeElement(), -1);
13466    }
13467    if (element.hasLatitudeElement()) {
13468      composeDecimal(t, "LocationPositionComponent", "latitude", element.getLatitudeElement(), -1);
13469    }
13470    if (element.hasAltitudeElement()) {
13471      composeDecimal(t, "LocationPositionComponent", "altitude", element.getAltitudeElement(), -1);
13472    }
13473  }
13474
13475  protected void composeLocationHoursOfOperationComponent(Complex parent, String parentType, String name, Location.LocationHoursOfOperationComponent element, int index) {
13476    if (element == null) 
13477      return;
13478    Complex t;
13479    if (Utilities.noString(parentType))
13480      t = parent;
13481    else {
13482      t = parent.predicate("fhir:"+parentType+'.'+name);
13483    }
13484    composeBackboneElement(t, "hoursOfOperation", name, element, index);
13485    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
13486      composeEnum(t, "LocationHoursOfOperationComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
13487    }
13488    if (element.hasAllDayElement()) {
13489      composeBoolean(t, "LocationHoursOfOperationComponent", "allDay", element.getAllDayElement(), -1);
13490    }
13491    if (element.hasOpeningTimeElement()) {
13492      composeTime(t, "LocationHoursOfOperationComponent", "openingTime", element.getOpeningTimeElement(), -1);
13493    }
13494    if (element.hasClosingTimeElement()) {
13495      composeTime(t, "LocationHoursOfOperationComponent", "closingTime", element.getClosingTimeElement(), -1);
13496    }
13497  }
13498
13499  protected void composeManufacturedItemDefinition(Complex parent, String parentType, String name, ManufacturedItemDefinition element, int index) {
13500    if (element == null) 
13501      return;
13502    Complex t;
13503    if (Utilities.noString(parentType))
13504      t = parent;
13505    else {
13506      t = parent.predicate("fhir:"+parentType+'.'+name);
13507    }
13508    composeDomainResource(t, "ManufacturedItemDefinition", name, element, index);
13509    for (int i = 0; i < element.getIdentifier().size(); i++) {
13510      composeIdentifier(t, "ManufacturedItemDefinition", "identifier", element.getIdentifier().get(i), i);
13511    }
13512    if (element.hasStatusElement()) {
13513      composeEnum(t, "ManufacturedItemDefinition", "status", element.getStatusElement(), -1);
13514    }
13515    if (element.hasManufacturedDoseForm()) {
13516      composeCodeableConcept(t, "ManufacturedItemDefinition", "manufacturedDoseForm", element.getManufacturedDoseForm(), -1);
13517    }
13518    if (element.hasUnitOfPresentation()) {
13519      composeCodeableConcept(t, "ManufacturedItemDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
13520    }
13521    for (int i = 0; i < element.getManufacturer().size(); i++) {
13522      composeReference(t, "ManufacturedItemDefinition", "manufacturer", element.getManufacturer().get(i), i);
13523    }
13524    for (int i = 0; i < element.getIngredient().size(); i++) {
13525      composeCodeableConcept(t, "ManufacturedItemDefinition", "ingredient", element.getIngredient().get(i), i);
13526    }
13527    for (int i = 0; i < element.getProperty().size(); i++) {
13528      composeManufacturedItemDefinitionPropertyComponent(t, "ManufacturedItemDefinition", "property", element.getProperty().get(i), i);
13529    }
13530  }
13531
13532  protected void composeManufacturedItemDefinitionPropertyComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionPropertyComponent element, int index) {
13533    if (element == null) 
13534      return;
13535    Complex t;
13536    if (Utilities.noString(parentType))
13537      t = parent;
13538    else {
13539      t = parent.predicate("fhir:"+parentType+'.'+name);
13540    }
13541    composeBackboneElement(t, "property", name, element, index);
13542    if (element.hasType()) {
13543      composeCodeableConcept(t, "ManufacturedItemDefinitionPropertyComponent", "type", element.getType(), -1);
13544    }
13545    if (element.hasValue()) {
13546      composeType(t, "ManufacturedItemDefinitionPropertyComponent", "value", element.getValue(), -1);
13547    }
13548  }
13549
13550  protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) {
13551    if (element == null) 
13552      return;
13553    Complex t;
13554    if (Utilities.noString(parentType))
13555      t = parent;
13556    else {
13557      t = parent.predicate("fhir:"+parentType+'.'+name);
13558    }
13559    composeDomainResource(t, "Measure", name, element, index);
13560    if (element.hasUrlElement()) {
13561      composeUri(t, "Measure", "url", element.getUrlElement(), -1);
13562    }
13563    for (int i = 0; i < element.getIdentifier().size(); i++) {
13564      composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i);
13565    }
13566    if (element.hasVersionElement()) {
13567      composeString(t, "Measure", "version", element.getVersionElement(), -1);
13568    }
13569    if (element.hasNameElement()) {
13570      composeString(t, "Measure", "name", element.getNameElement(), -1);
13571    }
13572    if (element.hasTitleElement()) {
13573      composeString(t, "Measure", "title", element.getTitleElement(), -1);
13574    }
13575    if (element.hasSubtitleElement()) {
13576      composeString(t, "Measure", "subtitle", element.getSubtitleElement(), -1);
13577    }
13578    if (element.hasStatusElement()) {
13579      composeEnum(t, "Measure", "status", element.getStatusElement(), -1);
13580    }
13581    if (element.hasExperimentalElement()) {
13582      composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1);
13583    }
13584    if (element.hasSubject()) {
13585      composeType(t, "Measure", "subject", element.getSubject(), -1);
13586    }
13587    if (element.hasDateElement()) {
13588      composeDateTime(t, "Measure", "date", element.getDateElement(), -1);
13589    }
13590    if (element.hasPublisherElement()) {
13591      composeString(t, "Measure", "publisher", element.getPublisherElement(), -1);
13592    }
13593    for (int i = 0; i < element.getContact().size(); i++) {
13594      composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i);
13595    }
13596    if (element.hasDescriptionElement()) {
13597      composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1);
13598    }
13599    for (int i = 0; i < element.getUseContext().size(); i++) {
13600      composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i);
13601    }
13602    for (int i = 0; i < element.getJurisdiction().size(); i++) {
13603      composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i);
13604    }
13605    if (element.hasPurposeElement()) {
13606      composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1);
13607    }
13608    if (element.hasUsageElement()) {
13609      composeString(t, "Measure", "usage", element.getUsageElement(), -1);
13610    }
13611    if (element.hasCopyrightElement()) {
13612      composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1);
13613    }
13614    if (element.hasApprovalDateElement()) {
13615      composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1);
13616    }
13617    if (element.hasLastReviewDateElement()) {
13618      composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1);
13619    }
13620    if (element.hasEffectivePeriod()) {
13621      composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1);
13622    }
13623    for (int i = 0; i < element.getTopic().size(); i++) {
13624      composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i);
13625    }
13626    for (int i = 0; i < element.getAuthor().size(); i++) {
13627      composeContactDetail(t, "Measure", "author", element.getAuthor().get(i), i);
13628    }
13629    for (int i = 0; i < element.getEditor().size(); i++) {
13630      composeContactDetail(t, "Measure", "editor", element.getEditor().get(i), i);
13631    }
13632    for (int i = 0; i < element.getReviewer().size(); i++) {
13633      composeContactDetail(t, "Measure", "reviewer", element.getReviewer().get(i), i);
13634    }
13635    for (int i = 0; i < element.getEndorser().size(); i++) {
13636      composeContactDetail(t, "Measure", "endorser", element.getEndorser().get(i), i);
13637    }
13638    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
13639      composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i);
13640    }
13641    for (int i = 0; i < element.getLibrary().size(); i++) {
13642      composeCanonical(t, "Measure", "library", element.getLibrary().get(i), i);
13643    }
13644    if (element.hasDisclaimerElement()) {
13645      composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1);
13646    }
13647    if (element.hasScoring()) {
13648      composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1);
13649    }
13650    if (element.hasCompositeScoring()) {
13651      composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1);
13652    }
13653    for (int i = 0; i < element.getType().size(); i++) {
13654      composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i);
13655    }
13656    if (element.hasRiskAdjustmentElement()) {
13657      composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1);
13658    }
13659    if (element.hasRateAggregationElement()) {
13660      composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1);
13661    }
13662    if (element.hasRationaleElement()) {
13663      composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1);
13664    }
13665    if (element.hasClinicalRecommendationStatementElement()) {
13666      composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1);
13667    }
13668    if (element.hasImprovementNotation()) {
13669      composeCodeableConcept(t, "Measure", "improvementNotation", element.getImprovementNotation(), -1);
13670    }
13671    for (int i = 0; i < element.getDefinition().size(); i++) {
13672      composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i);
13673    }
13674    if (element.hasGuidanceElement()) {
13675      composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1);
13676    }
13677    for (int i = 0; i < element.getGroup().size(); i++) {
13678      composeMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i);
13679    }
13680    for (int i = 0; i < element.getSupplementalData().size(); i++) {
13681      composeMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i);
13682    }
13683  }
13684
13685  protected void composeMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) {
13686    if (element == null) 
13687      return;
13688    Complex t;
13689    if (Utilities.noString(parentType))
13690      t = parent;
13691    else {
13692      t = parent.predicate("fhir:"+parentType+'.'+name);
13693    }
13694    composeBackboneElement(t, "group", name, element, index);
13695    if (element.hasCode()) {
13696      composeCodeableConcept(t, "MeasureGroupComponent", "code", element.getCode(), -1);
13697    }
13698    if (element.hasDescriptionElement()) {
13699      composeString(t, "MeasureGroupComponent", "description", element.getDescriptionElement(), -1);
13700    }
13701    for (int i = 0; i < element.getPopulation().size(); i++) {
13702      composeMeasureGroupPopulationComponent(t, "MeasureGroupComponent", "population", element.getPopulation().get(i), i);
13703    }
13704    for (int i = 0; i < element.getStratifier().size(); i++) {
13705      composeMeasureGroupStratifierComponent(t, "MeasureGroupComponent", "stratifier", element.getStratifier().get(i), i);
13706    }
13707  }
13708
13709  protected void composeMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) {
13710    if (element == null) 
13711      return;
13712    Complex t;
13713    if (Utilities.noString(parentType))
13714      t = parent;
13715    else {
13716      t = parent.predicate("fhir:"+parentType+'.'+name);
13717    }
13718    composeBackboneElement(t, "population", name, element, index);
13719    if (element.hasCode()) {
13720      composeCodeableConcept(t, "MeasureGroupPopulationComponent", "code", element.getCode(), -1);
13721    }
13722    if (element.hasDescriptionElement()) {
13723      composeString(t, "MeasureGroupPopulationComponent", "description", element.getDescriptionElement(), -1);
13724    }
13725    if (element.hasCriteria()) {
13726      composeExpression(t, "MeasureGroupPopulationComponent", "criteria", element.getCriteria(), -1);
13727    }
13728  }
13729
13730  protected void composeMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) {
13731    if (element == null) 
13732      return;
13733    Complex t;
13734    if (Utilities.noString(parentType))
13735      t = parent;
13736    else {
13737      t = parent.predicate("fhir:"+parentType+'.'+name);
13738    }
13739    composeBackboneElement(t, "stratifier", name, element, index);
13740    if (element.hasCode()) {
13741      composeCodeableConcept(t, "MeasureGroupStratifierComponent", "code", element.getCode(), -1);
13742    }
13743    if (element.hasDescriptionElement()) {
13744      composeString(t, "MeasureGroupStratifierComponent", "description", element.getDescriptionElement(), -1);
13745    }
13746    if (element.hasCriteria()) {
13747      composeExpression(t, "MeasureGroupStratifierComponent", "criteria", element.getCriteria(), -1);
13748    }
13749    for (int i = 0; i < element.getComponent().size(); i++) {
13750      composeMeasureGroupStratifierComponentComponent(t, "MeasureGroupStratifierComponent", "component", element.getComponent().get(i), i);
13751    }
13752  }
13753
13754  protected void composeMeasureGroupStratifierComponentComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponentComponent element, int index) {
13755    if (element == null) 
13756      return;
13757    Complex t;
13758    if (Utilities.noString(parentType))
13759      t = parent;
13760    else {
13761      t = parent.predicate("fhir:"+parentType+'.'+name);
13762    }
13763    composeBackboneElement(t, "component", name, element, index);
13764    if (element.hasCode()) {
13765      composeCodeableConcept(t, "MeasureGroupStratifierComponentComponent", "code", element.getCode(), -1);
13766    }
13767    if (element.hasDescriptionElement()) {
13768      composeString(t, "MeasureGroupStratifierComponentComponent", "description", element.getDescriptionElement(), -1);
13769    }
13770    if (element.hasCriteria()) {
13771      composeExpression(t, "MeasureGroupStratifierComponentComponent", "criteria", element.getCriteria(), -1);
13772    }
13773  }
13774
13775  protected void composeMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) {
13776    if (element == null) 
13777      return;
13778    Complex t;
13779    if (Utilities.noString(parentType))
13780      t = parent;
13781    else {
13782      t = parent.predicate("fhir:"+parentType+'.'+name);
13783    }
13784    composeBackboneElement(t, "supplementalData", name, element, index);
13785    if (element.hasCode()) {
13786      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "code", element.getCode(), -1);
13787    }
13788    for (int i = 0; i < element.getUsage().size(); i++) {
13789      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "usage", element.getUsage().get(i), i);
13790    }
13791    if (element.hasDescriptionElement()) {
13792      composeString(t, "MeasureSupplementalDataComponent", "description", element.getDescriptionElement(), -1);
13793    }
13794    if (element.hasCriteria()) {
13795      composeExpression(t, "MeasureSupplementalDataComponent", "criteria", element.getCriteria(), -1);
13796    }
13797  }
13798
13799  protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) {
13800    if (element == null) 
13801      return;
13802    Complex t;
13803    if (Utilities.noString(parentType))
13804      t = parent;
13805    else {
13806      t = parent.predicate("fhir:"+parentType+'.'+name);
13807    }
13808    composeDomainResource(t, "MeasureReport", name, element, index);
13809    for (int i = 0; i < element.getIdentifier().size(); i++) {
13810      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier().get(i), i);
13811    }
13812    if (element.hasStatusElement()) {
13813      composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1);
13814    }
13815    if (element.hasTypeElement()) {
13816      composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1);
13817    }
13818    if (element.hasMeasureElement()) {
13819      composeCanonical(t, "MeasureReport", "measure", element.getMeasureElement(), -1);
13820    }
13821    if (element.hasSubject()) {
13822      composeReference(t, "MeasureReport", "subject", element.getSubject(), -1);
13823    }
13824    if (element.hasDateElement()) {
13825      composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1);
13826    }
13827    if (element.hasReporter()) {
13828      composeReference(t, "MeasureReport", "reporter", element.getReporter(), -1);
13829    }
13830    if (element.hasPeriod()) {
13831      composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1);
13832    }
13833    if (element.hasImprovementNotation()) {
13834      composeCodeableConcept(t, "MeasureReport", "improvementNotation", element.getImprovementNotation(), -1);
13835    }
13836    for (int i = 0; i < element.getGroup().size(); i++) {
13837      composeMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i);
13838    }
13839    for (int i = 0; i < element.getEvaluatedResource().size(); i++) {
13840      composeReference(t, "MeasureReport", "evaluatedResource", element.getEvaluatedResource().get(i), i);
13841    }
13842  }
13843
13844  protected void composeMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) {
13845    if (element == null) 
13846      return;
13847    Complex t;
13848    if (Utilities.noString(parentType))
13849      t = parent;
13850    else {
13851      t = parent.predicate("fhir:"+parentType+'.'+name);
13852    }
13853    composeBackboneElement(t, "group", name, element, index);
13854    if (element.hasCode()) {
13855      composeCodeableConcept(t, "MeasureReportGroupComponent", "code", element.getCode(), -1);
13856    }
13857    for (int i = 0; i < element.getPopulation().size(); i++) {
13858      composeMeasureReportGroupPopulationComponent(t, "MeasureReportGroupComponent", "population", element.getPopulation().get(i), i);
13859    }
13860    if (element.hasMeasureScore()) {
13861      composeQuantity(t, "MeasureReportGroupComponent", "measureScore", element.getMeasureScore(), -1);
13862    }
13863    for (int i = 0; i < element.getStratifier().size(); i++) {
13864      composeMeasureReportGroupStratifierComponent(t, "MeasureReportGroupComponent", "stratifier", element.getStratifier().get(i), i);
13865    }
13866  }
13867
13868  protected void composeMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) {
13869    if (element == null) 
13870      return;
13871    Complex t;
13872    if (Utilities.noString(parentType))
13873      t = parent;
13874    else {
13875      t = parent.predicate("fhir:"+parentType+'.'+name);
13876    }
13877    composeBackboneElement(t, "population", name, element, index);
13878    if (element.hasCode()) {
13879      composeCodeableConcept(t, "MeasureReportGroupPopulationComponent", "code", element.getCode(), -1);
13880    }
13881    if (element.hasCountElement()) {
13882      composeInteger(t, "MeasureReportGroupPopulationComponent", "count", element.getCountElement(), -1);
13883    }
13884    if (element.hasSubjectResults()) {
13885      composeReference(t, "MeasureReportGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
13886    }
13887  }
13888
13889  protected void composeMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) {
13890    if (element == null) 
13891      return;
13892    Complex t;
13893    if (Utilities.noString(parentType))
13894      t = parent;
13895    else {
13896      t = parent.predicate("fhir:"+parentType+'.'+name);
13897    }
13898    composeBackboneElement(t, "stratifier", name, element, index);
13899    for (int i = 0; i < element.getCode().size(); i++) {
13900      composeCodeableConcept(t, "MeasureReportGroupStratifierComponent", "code", element.getCode().get(i), i);
13901    }
13902    for (int i = 0; i < element.getStratum().size(); i++) {
13903      composeMeasureReportStratifierGroupComponent(t, "MeasureReportGroupStratifierComponent", "stratum", element.getStratum().get(i), i);
13904    }
13905  }
13906
13907  protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) {
13908    if (element == null) 
13909      return;
13910    Complex t;
13911    if (Utilities.noString(parentType))
13912      t = parent;
13913    else {
13914      t = parent.predicate("fhir:"+parentType+'.'+name);
13915    }
13916    composeBackboneElement(t, "stratum", name, element, index);
13917    if (element.hasValue()) {
13918      composeCodeableConcept(t, "StratifierGroupComponent", "value", element.getValue(), -1);
13919    }
13920    for (int i = 0; i < element.getComponent().size(); i++) {
13921      composeMeasureReportStratifierGroupComponentComponent(t, "StratifierGroupComponent", "component", element.getComponent().get(i), i);
13922    }
13923    for (int i = 0; i < element.getPopulation().size(); i++) {
13924      composeMeasureReportStratifierGroupPopulationComponent(t, "StratifierGroupComponent", "population", element.getPopulation().get(i), i);
13925    }
13926    if (element.hasMeasureScore()) {
13927      composeQuantity(t, "StratifierGroupComponent", "measureScore", element.getMeasureScore(), -1);
13928    }
13929  }
13930
13931  protected void composeMeasureReportStratifierGroupComponentComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponentComponent element, int index) {
13932    if (element == null) 
13933      return;
13934    Complex t;
13935    if (Utilities.noString(parentType))
13936      t = parent;
13937    else {
13938      t = parent.predicate("fhir:"+parentType+'.'+name);
13939    }
13940    composeBackboneElement(t, "component", name, element, index);
13941    if (element.hasCode()) {
13942      composeCodeableConcept(t, "StratifierGroupComponentComponent", "code", element.getCode(), -1);
13943    }
13944    if (element.hasValue()) {
13945      composeCodeableConcept(t, "StratifierGroupComponentComponent", "value", element.getValue(), -1);
13946    }
13947  }
13948
13949  protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) {
13950    if (element == null) 
13951      return;
13952    Complex t;
13953    if (Utilities.noString(parentType))
13954      t = parent;
13955    else {
13956      t = parent.predicate("fhir:"+parentType+'.'+name);
13957    }
13958    composeBackboneElement(t, "population", name, element, index);
13959    if (element.hasCode()) {
13960      composeCodeableConcept(t, "StratifierGroupPopulationComponent", "code", element.getCode(), -1);
13961    }
13962    if (element.hasCountElement()) {
13963      composeInteger(t, "StratifierGroupPopulationComponent", "count", element.getCountElement(), -1);
13964    }
13965    if (element.hasSubjectResults()) {
13966      composeReference(t, "StratifierGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
13967    }
13968  }
13969
13970  protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) {
13971    if (element == null) 
13972      return;
13973    Complex t;
13974    if (Utilities.noString(parentType))
13975      t = parent;
13976    else {
13977      t = parent.predicate("fhir:"+parentType+'.'+name);
13978    }
13979    composeDomainResource(t, "Media", name, element, index);
13980    for (int i = 0; i < element.getIdentifier().size(); i++) {
13981      composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i);
13982    }
13983    for (int i = 0; i < element.getBasedOn().size(); i++) {
13984      composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i);
13985    }
13986    for (int i = 0; i < element.getPartOf().size(); i++) {
13987      composeReference(t, "Media", "partOf", element.getPartOf().get(i), i);
13988    }
13989    if (element.hasStatusElement()) {
13990      composeEnum(t, "Media", "status", element.getStatusElement(), -1);
13991    }
13992    if (element.hasType()) {
13993      composeCodeableConcept(t, "Media", "type", element.getType(), -1);
13994    }
13995    if (element.hasModality()) {
13996      composeCodeableConcept(t, "Media", "modality", element.getModality(), -1);
13997    }
13998    if (element.hasView()) {
13999      composeCodeableConcept(t, "Media", "view", element.getView(), -1);
14000    }
14001    if (element.hasSubject()) {
14002      composeReference(t, "Media", "subject", element.getSubject(), -1);
14003    }
14004    if (element.hasEncounter()) {
14005      composeReference(t, "Media", "encounter", element.getEncounter(), -1);
14006    }
14007    if (element.hasCreated()) {
14008      composeType(t, "Media", "created", element.getCreated(), -1);
14009    }
14010    if (element.hasIssuedElement()) {
14011      composeInstant(t, "Media", "issued", element.getIssuedElement(), -1);
14012    }
14013    if (element.hasOperator()) {
14014      composeReference(t, "Media", "operator", element.getOperator(), -1);
14015    }
14016    for (int i = 0; i < element.getReasonCode().size(); i++) {
14017      composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i);
14018    }
14019    if (element.hasBodySite()) {
14020      composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1);
14021    }
14022    if (element.hasDeviceNameElement()) {
14023      composeString(t, "Media", "deviceName", element.getDeviceNameElement(), -1);
14024    }
14025    if (element.hasDevice()) {
14026      composeReference(t, "Media", "device", element.getDevice(), -1);
14027    }
14028    if (element.hasHeightElement()) {
14029      composePositiveInt(t, "Media", "height", element.getHeightElement(), -1);
14030    }
14031    if (element.hasWidthElement()) {
14032      composePositiveInt(t, "Media", "width", element.getWidthElement(), -1);
14033    }
14034    if (element.hasFramesElement()) {
14035      composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1);
14036    }
14037    if (element.hasDurationElement()) {
14038      composeDecimal(t, "Media", "duration", element.getDurationElement(), -1);
14039    }
14040    if (element.hasContent()) {
14041      composeAttachment(t, "Media", "content", element.getContent(), -1);
14042    }
14043    for (int i = 0; i < element.getNote().size(); i++) {
14044      composeAnnotation(t, "Media", "note", element.getNote().get(i), i);
14045    }
14046  }
14047
14048  protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) {
14049    if (element == null) 
14050      return;
14051    Complex t;
14052    if (Utilities.noString(parentType))
14053      t = parent;
14054    else {
14055      t = parent.predicate("fhir:"+parentType+'.'+name);
14056    }
14057    composeDomainResource(t, "Medication", name, element, index);
14058    for (int i = 0; i < element.getIdentifier().size(); i++) {
14059      composeIdentifier(t, "Medication", "identifier", element.getIdentifier().get(i), i);
14060    }
14061    if (element.hasCode()) {
14062      composeCodeableConcept(t, "Medication", "code", element.getCode(), -1);
14063    }
14064    if (element.hasStatusElement()) {
14065      composeEnum(t, "Medication", "status", element.getStatusElement(), -1);
14066    }
14067    if (element.hasManufacturer()) {
14068      composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1);
14069    }
14070    if (element.hasForm()) {
14071      composeCodeableConcept(t, "Medication", "form", element.getForm(), -1);
14072    }
14073    if (element.hasAmount()) {
14074      composeRatio(t, "Medication", "amount", element.getAmount(), -1);
14075    }
14076    for (int i = 0; i < element.getIngredient().size(); i++) {
14077      composeMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i);
14078    }
14079    if (element.hasBatch()) {
14080      composeMedicationBatchComponent(t, "Medication", "batch", element.getBatch(), -1);
14081    }
14082  }
14083
14084  protected void composeMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) {
14085    if (element == null) 
14086      return;
14087    Complex t;
14088    if (Utilities.noString(parentType))
14089      t = parent;
14090    else {
14091      t = parent.predicate("fhir:"+parentType+'.'+name);
14092    }
14093    composeBackboneElement(t, "ingredient", name, element, index);
14094    if (element.hasItem()) {
14095      composeType(t, "MedicationIngredientComponent", "item", element.getItem(), -1);
14096    }
14097    if (element.hasIsActiveElement()) {
14098      composeBoolean(t, "MedicationIngredientComponent", "isActive", element.getIsActiveElement(), -1);
14099    }
14100    if (element.hasStrength()) {
14101      composeRatio(t, "MedicationIngredientComponent", "strength", element.getStrength(), -1);
14102    }
14103  }
14104
14105  protected void composeMedicationBatchComponent(Complex parent, String parentType, String name, Medication.MedicationBatchComponent element, int index) {
14106    if (element == null) 
14107      return;
14108    Complex t;
14109    if (Utilities.noString(parentType))
14110      t = parent;
14111    else {
14112      t = parent.predicate("fhir:"+parentType+'.'+name);
14113    }
14114    composeBackboneElement(t, "batch", name, element, index);
14115    if (element.hasLotNumberElement()) {
14116      composeString(t, "MedicationBatchComponent", "lotNumber", element.getLotNumberElement(), -1);
14117    }
14118    if (element.hasExpirationDateElement()) {
14119      composeDateTime(t, "MedicationBatchComponent", "expirationDate", element.getExpirationDateElement(), -1);
14120    }
14121  }
14122
14123  protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) {
14124    if (element == null) 
14125      return;
14126    Complex t;
14127    if (Utilities.noString(parentType))
14128      t = parent;
14129    else {
14130      t = parent.predicate("fhir:"+parentType+'.'+name);
14131    }
14132    composeDomainResource(t, "MedicationAdministration", name, element, index);
14133    for (int i = 0; i < element.getIdentifier().size(); i++) {
14134      composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i);
14135    }
14136    for (int i = 0; i < element.getInstantiates().size(); i++) {
14137      composeUri(t, "MedicationAdministration", "instantiates", element.getInstantiates().get(i), i);
14138    }
14139    for (int i = 0; i < element.getPartOf().size(); i++) {
14140      composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i);
14141    }
14142    if (element.hasStatusElement()) {
14143      composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1);
14144    }
14145    for (int i = 0; i < element.getStatusReason().size(); i++) {
14146      composeCodeableConcept(t, "MedicationAdministration", "statusReason", element.getStatusReason().get(i), i);
14147    }
14148    if (element.hasCategory()) {
14149      composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1);
14150    }
14151    if (element.hasMedication()) {
14152      composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1);
14153    }
14154    if (element.hasSubject()) {
14155      composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1);
14156    }
14157    if (element.hasContext()) {
14158      composeReference(t, "MedicationAdministration", "context", element.getContext(), -1);
14159    }
14160    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
14161      composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i);
14162    }
14163    if (element.hasEffective()) {
14164      composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1);
14165    }
14166    for (int i = 0; i < element.getPerformer().size(); i++) {
14167      composeMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i);
14168    }
14169    for (int i = 0; i < element.getReasonCode().size(); i++) {
14170      composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i);
14171    }
14172    for (int i = 0; i < element.getReasonReference().size(); i++) {
14173      composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i);
14174    }
14175    if (element.hasRequest()) {
14176      composeReference(t, "MedicationAdministration", "request", element.getRequest(), -1);
14177    }
14178    for (int i = 0; i < element.getDevice().size(); i++) {
14179      composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i);
14180    }
14181    for (int i = 0; i < element.getNote().size(); i++) {
14182      composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i);
14183    }
14184    if (element.hasDosage()) {
14185      composeMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1);
14186    }
14187    for (int i = 0; i < element.getEventHistory().size(); i++) {
14188      composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i);
14189    }
14190  }
14191
14192  protected void composeMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) {
14193    if (element == null) 
14194      return;
14195    Complex t;
14196    if (Utilities.noString(parentType))
14197      t = parent;
14198    else {
14199      t = parent.predicate("fhir:"+parentType+'.'+name);
14200    }
14201    composeBackboneElement(t, "performer", name, element, index);
14202    if (element.hasFunction()) {
14203      composeCodeableConcept(t, "MedicationAdministrationPerformerComponent", "function", element.getFunction(), -1);
14204    }
14205    if (element.hasActor()) {
14206      composeReference(t, "MedicationAdministrationPerformerComponent", "actor", element.getActor(), -1);
14207    }
14208  }
14209
14210  protected void composeMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) {
14211    if (element == null) 
14212      return;
14213    Complex t;
14214    if (Utilities.noString(parentType))
14215      t = parent;
14216    else {
14217      t = parent.predicate("fhir:"+parentType+'.'+name);
14218    }
14219    composeBackboneElement(t, "dosage", name, element, index);
14220    if (element.hasTextElement()) {
14221      composeString(t, "MedicationAdministrationDosageComponent", "text", element.getTextElement(), -1);
14222    }
14223    if (element.hasSite()) {
14224      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "site", element.getSite(), -1);
14225    }
14226    if (element.hasRoute()) {
14227      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "route", element.getRoute(), -1);
14228    }
14229    if (element.hasMethod()) {
14230      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "method", element.getMethod(), -1);
14231    }
14232    if (element.hasDose()) {
14233      composeQuantity(t, "MedicationAdministrationDosageComponent", "dose", element.getDose(), -1);
14234    }
14235    if (element.hasRate()) {
14236      composeType(t, "MedicationAdministrationDosageComponent", "rate", element.getRate(), -1);
14237    }
14238  }
14239
14240  protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) {
14241    if (element == null) 
14242      return;
14243    Complex t;
14244    if (Utilities.noString(parentType))
14245      t = parent;
14246    else {
14247      t = parent.predicate("fhir:"+parentType+'.'+name);
14248    }
14249    composeDomainResource(t, "MedicationDispense", name, element, index);
14250    for (int i = 0; i < element.getIdentifier().size(); i++) {
14251      composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i);
14252    }
14253    for (int i = 0; i < element.getPartOf().size(); i++) {
14254      composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i);
14255    }
14256    if (element.hasStatusElement()) {
14257      composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1);
14258    }
14259    if (element.hasStatusReason()) {
14260      composeType(t, "MedicationDispense", "statusReason", element.getStatusReason(), -1);
14261    }
14262    if (element.hasCategory()) {
14263      composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1);
14264    }
14265    if (element.hasMedication()) {
14266      composeType(t, "MedicationDispense", "medication", element.getMedication(), -1);
14267    }
14268    if (element.hasSubject()) {
14269      composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1);
14270    }
14271    if (element.hasContext()) {
14272      composeReference(t, "MedicationDispense", "context", element.getContext(), -1);
14273    }
14274    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
14275      composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i);
14276    }
14277    for (int i = 0; i < element.getPerformer().size(); i++) {
14278      composeMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i);
14279    }
14280    if (element.hasLocation()) {
14281      composeReference(t, "MedicationDispense", "location", element.getLocation(), -1);
14282    }
14283    for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) {
14284      composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i);
14285    }
14286    if (element.hasType()) {
14287      composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1);
14288    }
14289    if (element.hasQuantity()) {
14290      composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1);
14291    }
14292    if (element.hasDaysSupply()) {
14293      composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1);
14294    }
14295    if (element.hasWhenPreparedElement()) {
14296      composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1);
14297    }
14298    if (element.hasWhenHandedOverElement()) {
14299      composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
14300    }
14301    if (element.hasDestination()) {
14302      composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1);
14303    }
14304    for (int i = 0; i < element.getReceiver().size(); i++) {
14305      composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i);
14306    }
14307    for (int i = 0; i < element.getNote().size(); i++) {
14308      composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i);
14309    }
14310    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
14311      composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i);
14312    }
14313    if (element.hasSubstitution()) {
14314      composeMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1);
14315    }
14316    for (int i = 0; i < element.getDetectedIssue().size(); i++) {
14317      composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i);
14318    }
14319    for (int i = 0; i < element.getEventHistory().size(); i++) {
14320      composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i);
14321    }
14322  }
14323
14324  protected void composeMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) {
14325    if (element == null) 
14326      return;
14327    Complex t;
14328    if (Utilities.noString(parentType))
14329      t = parent;
14330    else {
14331      t = parent.predicate("fhir:"+parentType+'.'+name);
14332    }
14333    composeBackboneElement(t, "performer", name, element, index);
14334    if (element.hasFunction()) {
14335      composeCodeableConcept(t, "MedicationDispensePerformerComponent", "function", element.getFunction(), -1);
14336    }
14337    if (element.hasActor()) {
14338      composeReference(t, "MedicationDispensePerformerComponent", "actor", element.getActor(), -1);
14339    }
14340  }
14341
14342  protected void composeMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) {
14343    if (element == null) 
14344      return;
14345    Complex t;
14346    if (Utilities.noString(parentType))
14347      t = parent;
14348    else {
14349      t = parent.predicate("fhir:"+parentType+'.'+name);
14350    }
14351    composeBackboneElement(t, "substitution", name, element, index);
14352    if (element.hasWasSubstitutedElement()) {
14353      composeBoolean(t, "MedicationDispenseSubstitutionComponent", "wasSubstituted", element.getWasSubstitutedElement(), -1);
14354    }
14355    if (element.hasType()) {
14356      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "type", element.getType(), -1);
14357    }
14358    for (int i = 0; i < element.getReason().size(); i++) {
14359      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "reason", element.getReason().get(i), i);
14360    }
14361    for (int i = 0; i < element.getResponsibleParty().size(); i++) {
14362      composeReference(t, "MedicationDispenseSubstitutionComponent", "responsibleParty", element.getResponsibleParty().get(i), i);
14363    }
14364  }
14365
14366  protected void composeMedicationKnowledge(Complex parent, String parentType, String name, MedicationKnowledge element, int index) {
14367    if (element == null) 
14368      return;
14369    Complex t;
14370    if (Utilities.noString(parentType))
14371      t = parent;
14372    else {
14373      t = parent.predicate("fhir:"+parentType+'.'+name);
14374    }
14375    composeDomainResource(t, "MedicationKnowledge", name, element, index);
14376    if (element.hasCode()) {
14377      composeCodeableConcept(t, "MedicationKnowledge", "code", element.getCode(), -1);
14378    }
14379    if (element.hasStatusElement()) {
14380      composeEnum(t, "MedicationKnowledge", "status", element.getStatusElement(), -1);
14381    }
14382    if (element.hasManufacturer()) {
14383      composeReference(t, "MedicationKnowledge", "manufacturer", element.getManufacturer(), -1);
14384    }
14385    if (element.hasDoseForm()) {
14386      composeCodeableConcept(t, "MedicationKnowledge", "doseForm", element.getDoseForm(), -1);
14387    }
14388    if (element.hasAmount()) {
14389      composeQuantity(t, "MedicationKnowledge", "amount", element.getAmount(), -1);
14390    }
14391    for (int i = 0; i < element.getSynonym().size(); i++) {
14392      composeString(t, "MedicationKnowledge", "synonym", element.getSynonym().get(i), i);
14393    }
14394    for (int i = 0; i < element.getRelatedMedicationKnowledge().size(); i++) {
14395      composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(t, "MedicationKnowledge", "relatedMedicationKnowledge", element.getRelatedMedicationKnowledge().get(i), i);
14396    }
14397    for (int i = 0; i < element.getAssociatedMedication().size(); i++) {
14398      composeReference(t, "MedicationKnowledge", "associatedMedication", element.getAssociatedMedication().get(i), i);
14399    }
14400    for (int i = 0; i < element.getProductType().size(); i++) {
14401      composeCodeableConcept(t, "MedicationKnowledge", "productType", element.getProductType().get(i), i);
14402    }
14403    for (int i = 0; i < element.getMonograph().size(); i++) {
14404      composeMedicationKnowledgeMonographComponent(t, "MedicationKnowledge", "monograph", element.getMonograph().get(i), i);
14405    }
14406    for (int i = 0; i < element.getIngredient().size(); i++) {
14407      composeMedicationKnowledgeIngredientComponent(t, "MedicationKnowledge", "ingredient", element.getIngredient().get(i), i);
14408    }
14409    if (element.hasPreparationInstructionElement()) {
14410      composeMarkdown(t, "MedicationKnowledge", "preparationInstruction", element.getPreparationInstructionElement(), -1);
14411    }
14412    for (int i = 0; i < element.getIntendedRoute().size(); i++) {
14413      composeCodeableConcept(t, "MedicationKnowledge", "intendedRoute", element.getIntendedRoute().get(i), i);
14414    }
14415    for (int i = 0; i < element.getCost().size(); i++) {
14416      composeMedicationKnowledgeCostComponent(t, "MedicationKnowledge", "cost", element.getCost().get(i), i);
14417    }
14418    for (int i = 0; i < element.getMonitoringProgram().size(); i++) {
14419      composeMedicationKnowledgeMonitoringProgramComponent(t, "MedicationKnowledge", "monitoringProgram", element.getMonitoringProgram().get(i), i);
14420    }
14421    for (int i = 0; i < element.getAdministrationGuidelines().size(); i++) {
14422      composeMedicationKnowledgeAdministrationGuidelinesComponent(t, "MedicationKnowledge", "administrationGuidelines", element.getAdministrationGuidelines().get(i), i);
14423    }
14424    for (int i = 0; i < element.getMedicineClassification().size(); i++) {
14425      composeMedicationKnowledgeMedicineClassificationComponent(t, "MedicationKnowledge", "medicineClassification", element.getMedicineClassification().get(i), i);
14426    }
14427    if (element.hasPackaging()) {
14428      composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledge", "packaging", element.getPackaging(), -1);
14429    }
14430    for (int i = 0; i < element.getDrugCharacteristic().size(); i++) {
14431      composeMedicationKnowledgeDrugCharacteristicComponent(t, "MedicationKnowledge", "drugCharacteristic", element.getDrugCharacteristic().get(i), i);
14432    }
14433    for (int i = 0; i < element.getContraindication().size(); i++) {
14434      composeReference(t, "MedicationKnowledge", "contraindication", element.getContraindication().get(i), i);
14435    }
14436    for (int i = 0; i < element.getRegulatory().size(); i++) {
14437      composeMedicationKnowledgeRegulatoryComponent(t, "MedicationKnowledge", "regulatory", element.getRegulatory().get(i), i);
14438    }
14439    for (int i = 0; i < element.getKinetics().size(); i++) {
14440      composeMedicationKnowledgeKineticsComponent(t, "MedicationKnowledge", "kinetics", element.getKinetics().get(i), i);
14441    }
14442  }
14443
14444  protected void composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRelatedMedicationKnowledgeComponent element, int index) {
14445    if (element == null) 
14446      return;
14447    Complex t;
14448    if (Utilities.noString(parentType))
14449      t = parent;
14450    else {
14451      t = parent.predicate("fhir:"+parentType+'.'+name);
14452    }
14453    composeBackboneElement(t, "relatedMedicationKnowledge", name, element, index);
14454    if (element.hasType()) {
14455      composeCodeableConcept(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "type", element.getType(), -1);
14456    }
14457    for (int i = 0; i < element.getReference().size(); i++) {
14458      composeReference(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "reference", element.getReference().get(i), i);
14459    }
14460  }
14461
14462  protected void composeMedicationKnowledgeMonographComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonographComponent element, int index) {
14463    if (element == null) 
14464      return;
14465    Complex t;
14466    if (Utilities.noString(parentType))
14467      t = parent;
14468    else {
14469      t = parent.predicate("fhir:"+parentType+'.'+name);
14470    }
14471    composeBackboneElement(t, "monograph", name, element, index);
14472    if (element.hasType()) {
14473      composeCodeableConcept(t, "MedicationKnowledgeMonographComponent", "type", element.getType(), -1);
14474    }
14475    if (element.hasSource()) {
14476      composeReference(t, "MedicationKnowledgeMonographComponent", "source", element.getSource(), -1);
14477    }
14478  }
14479
14480  protected void composeMedicationKnowledgeIngredientComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIngredientComponent element, int index) {
14481    if (element == null) 
14482      return;
14483    Complex t;
14484    if (Utilities.noString(parentType))
14485      t = parent;
14486    else {
14487      t = parent.predicate("fhir:"+parentType+'.'+name);
14488    }
14489    composeBackboneElement(t, "ingredient", name, element, index);
14490    if (element.hasItem()) {
14491      composeType(t, "MedicationKnowledgeIngredientComponent", "item", element.getItem(), -1);
14492    }
14493    if (element.hasIsActiveElement()) {
14494      composeBoolean(t, "MedicationKnowledgeIngredientComponent", "isActive", element.getIsActiveElement(), -1);
14495    }
14496    if (element.hasStrength()) {
14497      composeRatio(t, "MedicationKnowledgeIngredientComponent", "strength", element.getStrength(), -1);
14498    }
14499  }
14500
14501  protected void composeMedicationKnowledgeCostComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeCostComponent element, int index) {
14502    if (element == null) 
14503      return;
14504    Complex t;
14505    if (Utilities.noString(parentType))
14506      t = parent;
14507    else {
14508      t = parent.predicate("fhir:"+parentType+'.'+name);
14509    }
14510    composeBackboneElement(t, "cost", name, element, index);
14511    if (element.hasType()) {
14512      composeCodeableConcept(t, "MedicationKnowledgeCostComponent", "type", element.getType(), -1);
14513    }
14514    if (element.hasSourceElement()) {
14515      composeString(t, "MedicationKnowledgeCostComponent", "source", element.getSourceElement(), -1);
14516    }
14517    if (element.hasCost()) {
14518      composeMoney(t, "MedicationKnowledgeCostComponent", "cost", element.getCost(), -1);
14519    }
14520  }
14521
14522  protected void composeMedicationKnowledgeMonitoringProgramComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonitoringProgramComponent element, int index) {
14523    if (element == null) 
14524      return;
14525    Complex t;
14526    if (Utilities.noString(parentType))
14527      t = parent;
14528    else {
14529      t = parent.predicate("fhir:"+parentType+'.'+name);
14530    }
14531    composeBackboneElement(t, "monitoringProgram", name, element, index);
14532    if (element.hasType()) {
14533      composeCodeableConcept(t, "MedicationKnowledgeMonitoringProgramComponent", "type", element.getType(), -1);
14534    }
14535    if (element.hasNameElement()) {
14536      composeString(t, "MedicationKnowledgeMonitoringProgramComponent", "name", element.getNameElement(), -1);
14537    }
14538  }
14539
14540  protected void composeMedicationKnowledgeAdministrationGuidelinesComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesComponent element, int index) {
14541    if (element == null) 
14542      return;
14543    Complex t;
14544    if (Utilities.noString(parentType))
14545      t = parent;
14546    else {
14547      t = parent.predicate("fhir:"+parentType+'.'+name);
14548    }
14549    composeBackboneElement(t, "administrationGuidelines", name, element, index);
14550    for (int i = 0; i < element.getDosage().size(); i++) {
14551      composeMedicationKnowledgeAdministrationGuidelinesDosageComponent(t, "MedicationKnowledgeAdministrationGuidelinesComponent", "dosage", element.getDosage().get(i), i);
14552    }
14553    if (element.hasIndication()) {
14554      composeType(t, "MedicationKnowledgeAdministrationGuidelinesComponent", "indication", element.getIndication(), -1);
14555    }
14556    for (int i = 0; i < element.getPatientCharacteristics().size(); i++) {
14557      composeMedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent(t, "MedicationKnowledgeAdministrationGuidelinesComponent", "patientCharacteristics", element.getPatientCharacteristics().get(i), i);
14558    }
14559  }
14560
14561  protected void composeMedicationKnowledgeAdministrationGuidelinesDosageComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesDosageComponent element, int index) {
14562    if (element == null) 
14563      return;
14564    Complex t;
14565    if (Utilities.noString(parentType))
14566      t = parent;
14567    else {
14568      t = parent.predicate("fhir:"+parentType+'.'+name);
14569    }
14570    composeBackboneElement(t, "dosage", name, element, index);
14571    if (element.hasType()) {
14572      composeCodeableConcept(t, "MedicationKnowledgeAdministrationGuidelinesDosageComponent", "type", element.getType(), -1);
14573    }
14574    for (int i = 0; i < element.getDosage().size(); i++) {
14575      composeDosage(t, "MedicationKnowledgeAdministrationGuidelinesDosageComponent", "dosage", element.getDosage().get(i), i);
14576    }
14577  }
14578
14579  protected void composeMedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent element, int index) {
14580    if (element == null) 
14581      return;
14582    Complex t;
14583    if (Utilities.noString(parentType))
14584      t = parent;
14585    else {
14586      t = parent.predicate("fhir:"+parentType+'.'+name);
14587    }
14588    composeBackboneElement(t, "patientCharacteristics", name, element, index);
14589    if (element.hasCharacteristic()) {
14590      composeType(t, "MedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent", "characteristic", element.getCharacteristic(), -1);
14591    }
14592    for (int i = 0; i < element.getValue().size(); i++) {
14593      composeString(t, "MedicationKnowledgeAdministrationGuidelinesPatientCharacteristicsComponent", "value", element.getValue().get(i), i);
14594    }
14595  }
14596
14597  protected void composeMedicationKnowledgeMedicineClassificationComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMedicineClassificationComponent element, int index) {
14598    if (element == null) 
14599      return;
14600    Complex t;
14601    if (Utilities.noString(parentType))
14602      t = parent;
14603    else {
14604      t = parent.predicate("fhir:"+parentType+'.'+name);
14605    }
14606    composeBackboneElement(t, "medicineClassification", name, element, index);
14607    if (element.hasType()) {
14608      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "type", element.getType(), -1);
14609    }
14610    for (int i = 0; i < element.getClassification().size(); i++) {
14611      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "classification", element.getClassification().get(i), i);
14612    }
14613  }
14614
14615  protected void composeMedicationKnowledgePackagingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgePackagingComponent element, int index) {
14616    if (element == null) 
14617      return;
14618    Complex t;
14619    if (Utilities.noString(parentType))
14620      t = parent;
14621    else {
14622      t = parent.predicate("fhir:"+parentType+'.'+name);
14623    }
14624    composeBackboneElement(t, "packaging", name, element, index);
14625    if (element.hasType()) {
14626      composeCodeableConcept(t, "MedicationKnowledgePackagingComponent", "type", element.getType(), -1);
14627    }
14628    if (element.hasQuantity()) {
14629      composeQuantity(t, "MedicationKnowledgePackagingComponent", "quantity", element.getQuantity(), -1);
14630    }
14631  }
14632
14633  protected void composeMedicationKnowledgeDrugCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDrugCharacteristicComponent element, int index) {
14634    if (element == null) 
14635      return;
14636    Complex t;
14637    if (Utilities.noString(parentType))
14638      t = parent;
14639    else {
14640      t = parent.predicate("fhir:"+parentType+'.'+name);
14641    }
14642    composeBackboneElement(t, "drugCharacteristic", name, element, index);
14643    if (element.hasType()) {
14644      composeCodeableConcept(t, "MedicationKnowledgeDrugCharacteristicComponent", "type", element.getType(), -1);
14645    }
14646    if (element.hasValue()) {
14647      composeType(t, "MedicationKnowledgeDrugCharacteristicComponent", "value", element.getValue(), -1);
14648    }
14649  }
14650
14651  protected void composeMedicationKnowledgeRegulatoryComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryComponent element, int index) {
14652    if (element == null) 
14653      return;
14654    Complex t;
14655    if (Utilities.noString(parentType))
14656      t = parent;
14657    else {
14658      t = parent.predicate("fhir:"+parentType+'.'+name);
14659    }
14660    composeBackboneElement(t, "regulatory", name, element, index);
14661    if (element.hasRegulatoryAuthority()) {
14662      composeReference(t, "MedicationKnowledgeRegulatoryComponent", "regulatoryAuthority", element.getRegulatoryAuthority(), -1);
14663    }
14664    for (int i = 0; i < element.getSubstitution().size(); i++) {
14665      composeMedicationKnowledgeRegulatorySubstitutionComponent(t, "MedicationKnowledgeRegulatoryComponent", "substitution", element.getSubstitution().get(i), i);
14666    }
14667    for (int i = 0; i < element.getSchedule().size(); i++) {
14668      composeMedicationKnowledgeRegulatoryScheduleComponent(t, "MedicationKnowledgeRegulatoryComponent", "schedule", element.getSchedule().get(i), i);
14669    }
14670    if (element.hasMaxDispense()) {
14671      composeMedicationKnowledgeRegulatoryMaxDispenseComponent(t, "MedicationKnowledgeRegulatoryComponent", "maxDispense", element.getMaxDispense(), -1);
14672    }
14673  }
14674
14675  protected void composeMedicationKnowledgeRegulatorySubstitutionComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatorySubstitutionComponent element, int index) {
14676    if (element == null) 
14677      return;
14678    Complex t;
14679    if (Utilities.noString(parentType))
14680      t = parent;
14681    else {
14682      t = parent.predicate("fhir:"+parentType+'.'+name);
14683    }
14684    composeBackboneElement(t, "substitution", name, element, index);
14685    if (element.hasType()) {
14686      composeCodeableConcept(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "type", element.getType(), -1);
14687    }
14688    if (element.hasAllowedElement()) {
14689      composeBoolean(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "allowed", element.getAllowedElement(), -1);
14690    }
14691  }
14692
14693  protected void composeMedicationKnowledgeRegulatoryScheduleComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryScheduleComponent element, int index) {
14694    if (element == null) 
14695      return;
14696    Complex t;
14697    if (Utilities.noString(parentType))
14698      t = parent;
14699    else {
14700      t = parent.predicate("fhir:"+parentType+'.'+name);
14701    }
14702    composeBackboneElement(t, "schedule", name, element, index);
14703    if (element.hasSchedule()) {
14704      composeCodeableConcept(t, "MedicationKnowledgeRegulatoryScheduleComponent", "schedule", element.getSchedule(), -1);
14705    }
14706  }
14707
14708  protected void composeMedicationKnowledgeRegulatoryMaxDispenseComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryMaxDispenseComponent element, int index) {
14709    if (element == null) 
14710      return;
14711    Complex t;
14712    if (Utilities.noString(parentType))
14713      t = parent;
14714    else {
14715      t = parent.predicate("fhir:"+parentType+'.'+name);
14716    }
14717    composeBackboneElement(t, "maxDispense", name, element, index);
14718    if (element.hasQuantity()) {
14719      composeQuantity(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "quantity", element.getQuantity(), -1);
14720    }
14721    if (element.hasPeriod()) {
14722      composeDuration(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "period", element.getPeriod(), -1);
14723    }
14724  }
14725
14726  protected void composeMedicationKnowledgeKineticsComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeKineticsComponent element, int index) {
14727    if (element == null) 
14728      return;
14729    Complex t;
14730    if (Utilities.noString(parentType))
14731      t = parent;
14732    else {
14733      t = parent.predicate("fhir:"+parentType+'.'+name);
14734    }
14735    composeBackboneElement(t, "kinetics", name, element, index);
14736    for (int i = 0; i < element.getAreaUnderCurve().size(); i++) {
14737      composeQuantity(t, "MedicationKnowledgeKineticsComponent", "areaUnderCurve", element.getAreaUnderCurve().get(i), i);
14738    }
14739    for (int i = 0; i < element.getLethalDose50().size(); i++) {
14740      composeQuantity(t, "MedicationKnowledgeKineticsComponent", "lethalDose50", element.getLethalDose50().get(i), i);
14741    }
14742    if (element.hasHalfLifePeriod()) {
14743      composeDuration(t, "MedicationKnowledgeKineticsComponent", "halfLifePeriod", element.getHalfLifePeriod(), -1);
14744    }
14745  }
14746
14747  protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) {
14748    if (element == null) 
14749      return;
14750    Complex t;
14751    if (Utilities.noString(parentType))
14752      t = parent;
14753    else {
14754      t = parent.predicate("fhir:"+parentType+'.'+name);
14755    }
14756    composeDomainResource(t, "MedicationRequest", name, element, index);
14757    for (int i = 0; i < element.getIdentifier().size(); i++) {
14758      composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i);
14759    }
14760    if (element.hasStatusElement()) {
14761      composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1);
14762    }
14763    if (element.hasStatusReason()) {
14764      composeCodeableConcept(t, "MedicationRequest", "statusReason", element.getStatusReason(), -1);
14765    }
14766    if (element.hasIntentElement()) {
14767      composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1);
14768    }
14769    for (int i = 0; i < element.getCategory().size(); i++) {
14770      composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory().get(i), i);
14771    }
14772    if (element.hasPriorityElement()) {
14773      composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1);
14774    }
14775    if (element.hasDoNotPerformElement()) {
14776      composeBoolean(t, "MedicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
14777    }
14778    if (element.hasReported()) {
14779      composeType(t, "MedicationRequest", "reported", element.getReported(), -1);
14780    }
14781    if (element.hasMedication()) {
14782      composeType(t, "MedicationRequest", "medication", element.getMedication(), -1);
14783    }
14784    if (element.hasSubject()) {
14785      composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1);
14786    }
14787    if (element.hasEncounter()) {
14788      composeReference(t, "MedicationRequest", "encounter", element.getEncounter(), -1);
14789    }
14790    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
14791      composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i);
14792    }
14793    if (element.hasAuthoredOnElement()) {
14794      composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
14795    }
14796    if (element.hasRequester()) {
14797      composeReference(t, "MedicationRequest", "requester", element.getRequester(), -1);
14798    }
14799    if (element.hasPerformer()) {
14800      composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1);
14801    }
14802    if (element.hasPerformerType()) {
14803      composeCodeableConcept(t, "MedicationRequest", "performerType", element.getPerformerType(), -1);
14804    }
14805    if (element.hasRecorder()) {
14806      composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1);
14807    }
14808    for (int i = 0; i < element.getReasonCode().size(); i++) {
14809      composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i);
14810    }
14811    for (int i = 0; i < element.getReasonReference().size(); i++) {
14812      composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i);
14813    }
14814    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
14815      composeCanonical(t, "MedicationRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
14816    }
14817    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
14818      composeUri(t, "MedicationRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
14819    }
14820    for (int i = 0; i < element.getBasedOn().size(); i++) {
14821      composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i);
14822    }
14823    if (element.hasGroupIdentifier()) {
14824      composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
14825    }
14826    if (element.hasCourseOfTherapyType()) {
14827      composeCodeableConcept(t, "MedicationRequest", "courseOfTherapyType", element.getCourseOfTherapyType(), -1);
14828    }
14829    for (int i = 0; i < element.getInsurance().size(); i++) {
14830      composeReference(t, "MedicationRequest", "insurance", element.getInsurance().get(i), i);
14831    }
14832    for (int i = 0; i < element.getNote().size(); i++) {
14833      composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i);
14834    }
14835    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
14836      composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i);
14837    }
14838    if (element.hasDispenseRequest()) {
14839      composeMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1);
14840    }
14841    if (element.hasSubstitution()) {
14842      composeMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1);
14843    }
14844    if (element.hasPriorPrescription()) {
14845      composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1);
14846    }
14847    for (int i = 0; i < element.getDetectedIssue().size(); i++) {
14848      composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i);
14849    }
14850    for (int i = 0; i < element.getEventHistory().size(); i++) {
14851      composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i);
14852    }
14853  }
14854
14855  protected void composeMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) {
14856    if (element == null) 
14857      return;
14858    Complex t;
14859    if (Utilities.noString(parentType))
14860      t = parent;
14861    else {
14862      t = parent.predicate("fhir:"+parentType+'.'+name);
14863    }
14864    composeBackboneElement(t, "dispenseRequest", name, element, index);
14865    if (element.hasInitialFill()) {
14866      composeMedicationRequestDispenseRequestInitialFillComponent(t, "MedicationRequestDispenseRequestComponent", "initialFill", element.getInitialFill(), -1);
14867    }
14868    if (element.hasDispenseInterval()) {
14869      composeDuration(t, "MedicationRequestDispenseRequestComponent", "dispenseInterval", element.getDispenseInterval(), -1);
14870    }
14871    if (element.hasValidityPeriod()) {
14872      composePeriod(t, "MedicationRequestDispenseRequestComponent", "validityPeriod", element.getValidityPeriod(), -1);
14873    }
14874    if (element.hasNumberOfRepeatsAllowedElement()) {
14875      composeUnsignedInt(t, "MedicationRequestDispenseRequestComponent", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1);
14876    }
14877    if (element.hasQuantity()) {
14878      composeQuantity(t, "MedicationRequestDispenseRequestComponent", "quantity", element.getQuantity(), -1);
14879    }
14880    if (element.hasExpectedSupplyDuration()) {
14881      composeDuration(t, "MedicationRequestDispenseRequestComponent", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1);
14882    }
14883    if (element.hasPerformer()) {
14884      composeReference(t, "MedicationRequestDispenseRequestComponent", "performer", element.getPerformer(), -1);
14885    }
14886  }
14887
14888  protected void composeMedicationRequestDispenseRequestInitialFillComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestInitialFillComponent element, int index) {
14889    if (element == null) 
14890      return;
14891    Complex t;
14892    if (Utilities.noString(parentType))
14893      t = parent;
14894    else {
14895      t = parent.predicate("fhir:"+parentType+'.'+name);
14896    }
14897    composeBackboneElement(t, "initialFill", name, element, index);
14898    if (element.hasQuantity()) {
14899      composeQuantity(t, "MedicationRequestDispenseRequestInitialFillComponent", "quantity", element.getQuantity(), -1);
14900    }
14901    if (element.hasDuration()) {
14902      composeDuration(t, "MedicationRequestDispenseRequestInitialFillComponent", "duration", element.getDuration(), -1);
14903    }
14904  }
14905
14906  protected void composeMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) {
14907    if (element == null) 
14908      return;
14909    Complex t;
14910    if (Utilities.noString(parentType))
14911      t = parent;
14912    else {
14913      t = parent.predicate("fhir:"+parentType+'.'+name);
14914    }
14915    composeBackboneElement(t, "substitution", name, element, index);
14916    if (element.hasAllowed()) {
14917      composeType(t, "MedicationRequestSubstitutionComponent", "allowed", element.getAllowed(), -1);
14918    }
14919    if (element.hasReason()) {
14920      composeCodeableConcept(t, "MedicationRequestSubstitutionComponent", "reason", element.getReason(), -1);
14921    }
14922  }
14923
14924  protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) {
14925    if (element == null) 
14926      return;
14927    Complex t;
14928    if (Utilities.noString(parentType))
14929      t = parent;
14930    else {
14931      t = parent.predicate("fhir:"+parentType+'.'+name);
14932    }
14933    composeDomainResource(t, "MedicationStatement", name, element, index);
14934    for (int i = 0; i < element.getIdentifier().size(); i++) {
14935      composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i);
14936    }
14937    for (int i = 0; i < element.getBasedOn().size(); i++) {
14938      composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i);
14939    }
14940    for (int i = 0; i < element.getPartOf().size(); i++) {
14941      composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i);
14942    }
14943    if (element.hasStatusElement()) {
14944      composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1);
14945    }
14946    for (int i = 0; i < element.getStatusReason().size(); i++) {
14947      composeCodeableConcept(t, "MedicationStatement", "statusReason", element.getStatusReason().get(i), i);
14948    }
14949    if (element.hasCategory()) {
14950      composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1);
14951    }
14952    if (element.hasMedication()) {
14953      composeType(t, "MedicationStatement", "medication", element.getMedication(), -1);
14954    }
14955    if (element.hasSubject()) {
14956      composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1);
14957    }
14958    if (element.hasContext()) {
14959      composeReference(t, "MedicationStatement", "context", element.getContext(), -1);
14960    }
14961    if (element.hasEffective()) {
14962      composeType(t, "MedicationStatement", "effective", element.getEffective(), -1);
14963    }
14964    if (element.hasDateAssertedElement()) {
14965      composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1);
14966    }
14967    if (element.hasInformationSource()) {
14968      composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1);
14969    }
14970    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
14971      composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
14972    }
14973    for (int i = 0; i < element.getReasonCode().size(); i++) {
14974      composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i);
14975    }
14976    for (int i = 0; i < element.getReasonReference().size(); i++) {
14977      composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i);
14978    }
14979    for (int i = 0; i < element.getNote().size(); i++) {
14980      composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i);
14981    }
14982    for (int i = 0; i < element.getDosage().size(); i++) {
14983      composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i);
14984    }
14985  }
14986
14987  protected void composeMedicinalProductDefinition(Complex parent, String parentType, String name, MedicinalProductDefinition element, int index) {
14988    if (element == null) 
14989      return;
14990    Complex t;
14991    if (Utilities.noString(parentType))
14992      t = parent;
14993    else {
14994      t = parent.predicate("fhir:"+parentType+'.'+name);
14995    }
14996    composeDomainResource(t, "MedicinalProductDefinition", name, element, index);
14997    for (int i = 0; i < element.getIdentifier().size(); i++) {
14998      composeIdentifier(t, "MedicinalProductDefinition", "identifier", element.getIdentifier().get(i), i);
14999    }
15000    if (element.hasType()) {
15001      composeCodeableConcept(t, "MedicinalProductDefinition", "type", element.getType(), -1);
15002    }
15003    if (element.hasDomain()) {
15004      composeCodeableConcept(t, "MedicinalProductDefinition", "domain", element.getDomain(), -1);
15005    }
15006    if (element.hasVersionElement()) {
15007      composeString(t, "MedicinalProductDefinition", "version", element.getVersionElement(), -1);
15008    }
15009    if (element.hasStatus()) {
15010      composeCodeableConcept(t, "MedicinalProductDefinition", "status", element.getStatus(), -1);
15011    }
15012    if (element.hasStatusDateElement()) {
15013      composeDateTime(t, "MedicinalProductDefinition", "statusDate", element.getStatusDateElement(), -1);
15014    }
15015    if (element.hasDescriptionElement()) {
15016      composeMarkdown(t, "MedicinalProductDefinition", "description", element.getDescriptionElement(), -1);
15017    }
15018    if (element.hasCombinedPharmaceuticalDoseForm()) {
15019      composeCodeableConcept(t, "MedicinalProductDefinition", "combinedPharmaceuticalDoseForm", element.getCombinedPharmaceuticalDoseForm(), -1);
15020    }
15021    for (int i = 0; i < element.getRoute().size(); i++) {
15022      composeCodeableConcept(t, "MedicinalProductDefinition", "route", element.getRoute().get(i), i);
15023    }
15024    if (element.hasIndicationElement()) {
15025      composeMarkdown(t, "MedicinalProductDefinition", "indication", element.getIndicationElement(), -1);
15026    }
15027    if (element.hasLegalStatusOfSupply()) {
15028      composeCodeableConcept(t, "MedicinalProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1);
15029    }
15030    if (element.hasAdditionalMonitoringIndicator()) {
15031      composeCodeableConcept(t, "MedicinalProductDefinition", "additionalMonitoringIndicator", element.getAdditionalMonitoringIndicator(), -1);
15032    }
15033    for (int i = 0; i < element.getSpecialMeasures().size(); i++) {
15034      composeCodeableConcept(t, "MedicinalProductDefinition", "specialMeasures", element.getSpecialMeasures().get(i), i);
15035    }
15036    if (element.hasPediatricUseIndicator()) {
15037      composeCodeableConcept(t, "MedicinalProductDefinition", "pediatricUseIndicator", element.getPediatricUseIndicator(), -1);
15038    }
15039    for (int i = 0; i < element.getClassification().size(); i++) {
15040      composeCodeableConcept(t, "MedicinalProductDefinition", "classification", element.getClassification().get(i), i);
15041    }
15042    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
15043      composeMarketingStatus(t, "MedicinalProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
15044    }
15045    for (int i = 0; i < element.getPackagedMedicinalProduct().size(); i++) {
15046      composeCodeableConcept(t, "MedicinalProductDefinition", "packagedMedicinalProduct", element.getPackagedMedicinalProduct().get(i), i);
15047    }
15048    for (int i = 0; i < element.getIngredient().size(); i++) {
15049      composeCodeableConcept(t, "MedicinalProductDefinition", "ingredient", element.getIngredient().get(i), i);
15050    }
15051    for (int i = 0; i < element.getImpurity().size(); i++) {
15052      composeCodeableReference(t, "MedicinalProductDefinition", "impurity", element.getImpurity().get(i), i);
15053    }
15054    for (int i = 0; i < element.getAttachedDocument().size(); i++) {
15055      composeReference(t, "MedicinalProductDefinition", "attachedDocument", element.getAttachedDocument().get(i), i);
15056    }
15057    for (int i = 0; i < element.getMasterFile().size(); i++) {
15058      composeReference(t, "MedicinalProductDefinition", "masterFile", element.getMasterFile().get(i), i);
15059    }
15060    for (int i = 0; i < element.getContact().size(); i++) {
15061      composeMedicinalProductDefinitionContactComponent(t, "MedicinalProductDefinition", "contact", element.getContact().get(i), i);
15062    }
15063    for (int i = 0; i < element.getClinicalTrial().size(); i++) {
15064      composeReference(t, "MedicinalProductDefinition", "clinicalTrial", element.getClinicalTrial().get(i), i);
15065    }
15066    for (int i = 0; i < element.getCode().size(); i++) {
15067      composeCoding(t, "MedicinalProductDefinition", "code", element.getCode().get(i), i);
15068    }
15069    for (int i = 0; i < element.getName().size(); i++) {
15070      composeMedicinalProductDefinitionNameComponent(t, "MedicinalProductDefinition", "name", element.getName().get(i), i);
15071    }
15072    for (int i = 0; i < element.getCrossReference().size(); i++) {
15073      composeMedicinalProductDefinitionCrossReferenceComponent(t, "MedicinalProductDefinition", "crossReference", element.getCrossReference().get(i), i);
15074    }
15075    for (int i = 0; i < element.getOperation().size(); i++) {
15076      composeMedicinalProductDefinitionOperationComponent(t, "MedicinalProductDefinition", "operation", element.getOperation().get(i), i);
15077    }
15078    for (int i = 0; i < element.getCharacteristic().size(); i++) {
15079      composeMedicinalProductDefinitionCharacteristicComponent(t, "MedicinalProductDefinition", "characteristic", element.getCharacteristic().get(i), i);
15080    }
15081  }
15082
15083  protected void composeMedicinalProductDefinitionContactComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionContactComponent element, int index) {
15084    if (element == null) 
15085      return;
15086    Complex t;
15087    if (Utilities.noString(parentType))
15088      t = parent;
15089    else {
15090      t = parent.predicate("fhir:"+parentType+'.'+name);
15091    }
15092    composeBackboneElement(t, "contact", name, element, index);
15093    if (element.hasType()) {
15094      composeCodeableConcept(t, "MedicinalProductDefinitionContactComponent", "type", element.getType(), -1);
15095    }
15096    if (element.hasContact()) {
15097      composeReference(t, "MedicinalProductDefinitionContactComponent", "contact", element.getContact(), -1);
15098    }
15099  }
15100
15101  protected void composeMedicinalProductDefinitionNameComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameComponent element, int index) {
15102    if (element == null) 
15103      return;
15104    Complex t;
15105    if (Utilities.noString(parentType))
15106      t = parent;
15107    else {
15108      t = parent.predicate("fhir:"+parentType+'.'+name);
15109    }
15110    composeBackboneElement(t, "name", name, element, index);
15111    if (element.hasProductNameElement()) {
15112      composeString(t, "MedicinalProductDefinitionNameComponent", "productName", element.getProductNameElement(), -1);
15113    }
15114    if (element.hasType()) {
15115      composeCodeableConcept(t, "MedicinalProductDefinitionNameComponent", "type", element.getType(), -1);
15116    }
15117    for (int i = 0; i < element.getNamePart().size(); i++) {
15118      composeMedicinalProductDefinitionNameNamePartComponent(t, "MedicinalProductDefinitionNameComponent", "namePart", element.getNamePart().get(i), i);
15119    }
15120    for (int i = 0; i < element.getCountryLanguage().size(); i++) {
15121      composeMedicinalProductDefinitionNameCountryLanguageComponent(t, "MedicinalProductDefinitionNameComponent", "countryLanguage", element.getCountryLanguage().get(i), i);
15122    }
15123  }
15124
15125  protected void composeMedicinalProductDefinitionNameNamePartComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameNamePartComponent element, int index) {
15126    if (element == null) 
15127      return;
15128    Complex t;
15129    if (Utilities.noString(parentType))
15130      t = parent;
15131    else {
15132      t = parent.predicate("fhir:"+parentType+'.'+name);
15133    }
15134    composeBackboneElement(t, "namePart", name, element, index);
15135    if (element.hasPartElement()) {
15136      composeString(t, "MedicinalProductDefinitionNameNamePartComponent", "part", element.getPartElement(), -1);
15137    }
15138    if (element.hasType()) {
15139      composeCodeableConcept(t, "MedicinalProductDefinitionNameNamePartComponent", "type", element.getType(), -1);
15140    }
15141  }
15142
15143  protected void composeMedicinalProductDefinitionNameCountryLanguageComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameCountryLanguageComponent element, int index) {
15144    if (element == null) 
15145      return;
15146    Complex t;
15147    if (Utilities.noString(parentType))
15148      t = parent;
15149    else {
15150      t = parent.predicate("fhir:"+parentType+'.'+name);
15151    }
15152    composeBackboneElement(t, "countryLanguage", name, element, index);
15153    if (element.hasCountry()) {
15154      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "country", element.getCountry(), -1);
15155    }
15156    if (element.hasJurisdiction()) {
15157      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "jurisdiction", element.getJurisdiction(), -1);
15158    }
15159    if (element.hasLanguage()) {
15160      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "language", element.getLanguage(), -1);
15161    }
15162  }
15163
15164  protected void composeMedicinalProductDefinitionCrossReferenceComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCrossReferenceComponent element, int index) {
15165    if (element == null) 
15166      return;
15167    Complex t;
15168    if (Utilities.noString(parentType))
15169      t = parent;
15170    else {
15171      t = parent.predicate("fhir:"+parentType+'.'+name);
15172    }
15173    composeBackboneElement(t, "crossReference", name, element, index);
15174    if (element.hasProduct()) {
15175      composeCodeableReference(t, "MedicinalProductDefinitionCrossReferenceComponent", "product", element.getProduct(), -1);
15176    }
15177    if (element.hasType()) {
15178      composeCodeableConcept(t, "MedicinalProductDefinitionCrossReferenceComponent", "type", element.getType(), -1);
15179    }
15180  }
15181
15182  protected void composeMedicinalProductDefinitionOperationComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionOperationComponent element, int index) {
15183    if (element == null) 
15184      return;
15185    Complex t;
15186    if (Utilities.noString(parentType))
15187      t = parent;
15188    else {
15189      t = parent.predicate("fhir:"+parentType+'.'+name);
15190    }
15191    composeBackboneElement(t, "operation", name, element, index);
15192    if (element.hasType()) {
15193      composeCodeableReference(t, "MedicinalProductDefinitionOperationComponent", "type", element.getType(), -1);
15194    }
15195    if (element.hasEffectiveDate()) {
15196      composePeriod(t, "MedicinalProductDefinitionOperationComponent", "effectiveDate", element.getEffectiveDate(), -1);
15197    }
15198    for (int i = 0; i < element.getOrganization().size(); i++) {
15199      composeReference(t, "MedicinalProductDefinitionOperationComponent", "organization", element.getOrganization().get(i), i);
15200    }
15201    if (element.hasConfidentialityIndicator()) {
15202      composeCodeableConcept(t, "MedicinalProductDefinitionOperationComponent", "confidentialityIndicator", element.getConfidentialityIndicator(), -1);
15203    }
15204  }
15205
15206  protected void composeMedicinalProductDefinitionCharacteristicComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCharacteristicComponent element, int index) {
15207    if (element == null) 
15208      return;
15209    Complex t;
15210    if (Utilities.noString(parentType))
15211      t = parent;
15212    else {
15213      t = parent.predicate("fhir:"+parentType+'.'+name);
15214    }
15215    composeBackboneElement(t, "characteristic", name, element, index);
15216    if (element.hasType()) {
15217      composeCodeableConcept(t, "MedicinalProductDefinitionCharacteristicComponent", "type", element.getType(), -1);
15218    }
15219    if (element.hasValue()) {
15220      composeType(t, "MedicinalProductDefinitionCharacteristicComponent", "value", element.getValue(), -1);
15221    }
15222  }
15223
15224  protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) {
15225    if (element == null) 
15226      return;
15227    Complex t;
15228    if (Utilities.noString(parentType))
15229      t = parent;
15230    else {
15231      t = parent.predicate("fhir:"+parentType+'.'+name);
15232    }
15233    composeDomainResource(t, "MessageDefinition", name, element, index);
15234    if (element.hasUrlElement()) {
15235      composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1);
15236    }
15237    for (int i = 0; i < element.getIdentifier().size(); i++) {
15238      composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier().get(i), i);
15239    }
15240    if (element.hasVersionElement()) {
15241      composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1);
15242    }
15243    if (element.hasNameElement()) {
15244      composeString(t, "MessageDefinition", "name", element.getNameElement(), -1);
15245    }
15246    if (element.hasTitleElement()) {
15247      composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1);
15248    }
15249    for (int i = 0; i < element.getReplaces().size(); i++) {
15250      composeCanonical(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i);
15251    }
15252    if (element.hasStatusElement()) {
15253      composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1);
15254    }
15255    if (element.hasExperimentalElement()) {
15256      composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1);
15257    }
15258    if (element.hasDateElement()) {
15259      composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1);
15260    }
15261    if (element.hasPublisherElement()) {
15262      composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1);
15263    }
15264    for (int i = 0; i < element.getContact().size(); i++) {
15265      composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i);
15266    }
15267    if (element.hasDescriptionElement()) {
15268      composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1);
15269    }
15270    for (int i = 0; i < element.getUseContext().size(); i++) {
15271      composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i);
15272    }
15273    for (int i = 0; i < element.getJurisdiction().size(); i++) {
15274      composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
15275    }
15276    if (element.hasPurposeElement()) {
15277      composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1);
15278    }
15279    if (element.hasCopyrightElement()) {
15280      composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1);
15281    }
15282    if (element.hasBaseElement()) {
15283      composeCanonical(t, "MessageDefinition", "base", element.getBaseElement(), -1);
15284    }
15285    for (int i = 0; i < element.getParent().size(); i++) {
15286      composeCanonical(t, "MessageDefinition", "parent", element.getParent().get(i), i);
15287    }
15288    if (element.hasEvent()) {
15289      composeType(t, "MessageDefinition", "event", element.getEvent(), -1);
15290    }
15291    if (element.hasCategoryElement()) {
15292      composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1);
15293    }
15294    for (int i = 0; i < element.getFocus().size(); i++) {
15295      composeMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i);
15296    }
15297    if (element.hasResponseRequiredElement()) {
15298      composeEnum(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1);
15299    }
15300    for (int i = 0; i < element.getAllowedResponse().size(); i++) {
15301      composeMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i);
15302    }
15303    for (int i = 0; i < element.getGraph().size(); i++) {
15304      composeCanonical(t, "MessageDefinition", "graph", element.getGraph().get(i), i);
15305    }
15306  }
15307
15308  protected void composeMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) {
15309    if (element == null) 
15310      return;
15311    Complex t;
15312    if (Utilities.noString(parentType))
15313      t = parent;
15314    else {
15315      t = parent.predicate("fhir:"+parentType+'.'+name);
15316    }
15317    composeBackboneElement(t, "focus", name, element, index);
15318    if (element.hasCodeElement()) {
15319      composeCode(t, "MessageDefinitionFocusComponent", "code", element.getCodeElement(), -1);
15320    }
15321    if (element.hasProfileElement()) {
15322      composeCanonical(t, "MessageDefinitionFocusComponent", "profile", element.getProfileElement(), -1);
15323    }
15324    if (element.hasMinElement()) {
15325      composeUnsignedInt(t, "MessageDefinitionFocusComponent", "min", element.getMinElement(), -1);
15326    }
15327    if (element.hasMaxElement()) {
15328      composeString(t, "MessageDefinitionFocusComponent", "max", element.getMaxElement(), -1);
15329    }
15330  }
15331
15332  protected void composeMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) {
15333    if (element == null) 
15334      return;
15335    Complex t;
15336    if (Utilities.noString(parentType))
15337      t = parent;
15338    else {
15339      t = parent.predicate("fhir:"+parentType+'.'+name);
15340    }
15341    composeBackboneElement(t, "allowedResponse", name, element, index);
15342    if (element.hasMessageElement()) {
15343      composeCanonical(t, "MessageDefinitionAllowedResponseComponent", "message", element.getMessageElement(), -1);
15344    }
15345    if (element.hasSituationElement()) {
15346      composeMarkdown(t, "MessageDefinitionAllowedResponseComponent", "situation", element.getSituationElement(), -1);
15347    }
15348  }
15349
15350  protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) {
15351    if (element == null) 
15352      return;
15353    Complex t;
15354    if (Utilities.noString(parentType))
15355      t = parent;
15356    else {
15357      t = parent.predicate("fhir:"+parentType+'.'+name);
15358    }
15359    composeDomainResource(t, "MessageHeader", name, element, index);
15360    if (element.hasEvent()) {
15361      composeType(t, "MessageHeader", "event", element.getEvent(), -1);
15362    }
15363    for (int i = 0; i < element.getDestination().size(); i++) {
15364      composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i);
15365    }
15366    if (element.hasSender()) {
15367      composeReference(t, "MessageHeader", "sender", element.getSender(), -1);
15368    }
15369    if (element.hasEnterer()) {
15370      composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1);
15371    }
15372    if (element.hasAuthor()) {
15373      composeReference(t, "MessageHeader", "author", element.getAuthor(), -1);
15374    }
15375    if (element.hasSource()) {
15376      composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1);
15377    }
15378    if (element.hasResponsible()) {
15379      composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1);
15380    }
15381    if (element.hasReason()) {
15382      composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1);
15383    }
15384    if (element.hasResponse()) {
15385      composeMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1);
15386    }
15387    for (int i = 0; i < element.getFocus().size(); i++) {
15388      composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i);
15389    }
15390    if (element.hasDefinitionElement()) {
15391      composeCanonical(t, "MessageHeader", "definition", element.getDefinitionElement(), -1);
15392    }
15393  }
15394
15395  protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) {
15396    if (element == null) 
15397      return;
15398    Complex t;
15399    if (Utilities.noString(parentType))
15400      t = parent;
15401    else {
15402      t = parent.predicate("fhir:"+parentType+'.'+name);
15403    }
15404    composeBackboneElement(t, "destination", name, element, index);
15405    if (element.hasNameElement()) {
15406      composeString(t, "MessageDestinationComponent", "name", element.getNameElement(), -1);
15407    }
15408    if (element.hasTarget()) {
15409      composeReference(t, "MessageDestinationComponent", "target", element.getTarget(), -1);
15410    }
15411    if (element.hasEndpointElement()) {
15412      composeUrl(t, "MessageDestinationComponent", "endpoint", element.getEndpointElement(), -1);
15413    }
15414    if (element.hasReceiver()) {
15415      composeReference(t, "MessageDestinationComponent", "receiver", element.getReceiver(), -1);
15416    }
15417  }
15418
15419  protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) {
15420    if (element == null) 
15421      return;
15422    Complex t;
15423    if (Utilities.noString(parentType))
15424      t = parent;
15425    else {
15426      t = parent.predicate("fhir:"+parentType+'.'+name);
15427    }
15428    composeBackboneElement(t, "source", name, element, index);
15429    if (element.hasNameElement()) {
15430      composeString(t, "MessageSourceComponent", "name", element.getNameElement(), -1);
15431    }
15432    if (element.hasSoftwareElement()) {
15433      composeString(t, "MessageSourceComponent", "software", element.getSoftwareElement(), -1);
15434    }
15435    if (element.hasVersionElement()) {
15436      composeString(t, "MessageSourceComponent", "version", element.getVersionElement(), -1);
15437    }
15438    if (element.hasContact()) {
15439      composeContactPoint(t, "MessageSourceComponent", "contact", element.getContact(), -1);
15440    }
15441    if (element.hasEndpointElement()) {
15442      composeUrl(t, "MessageSourceComponent", "endpoint", element.getEndpointElement(), -1);
15443    }
15444  }
15445
15446  protected void composeMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) {
15447    if (element == null) 
15448      return;
15449    Complex t;
15450    if (Utilities.noString(parentType))
15451      t = parent;
15452    else {
15453      t = parent.predicate("fhir:"+parentType+'.'+name);
15454    }
15455    composeBackboneElement(t, "response", name, element, index);
15456    if (element.hasIdentifierElement()) {
15457      composeId(t, "MessageHeaderResponseComponent", "identifier", element.getIdentifierElement(), -1);
15458    }
15459    if (element.hasCodeElement()) {
15460      composeEnum(t, "MessageHeaderResponseComponent", "code", element.getCodeElement(), -1);
15461    }
15462    if (element.hasDetails()) {
15463      composeReference(t, "MessageHeaderResponseComponent", "details", element.getDetails(), -1);
15464    }
15465  }
15466
15467  protected void composeMolecularSequence(Complex parent, String parentType, String name, MolecularSequence element, int index) {
15468    if (element == null) 
15469      return;
15470    Complex t;
15471    if (Utilities.noString(parentType))
15472      t = parent;
15473    else {
15474      t = parent.predicate("fhir:"+parentType+'.'+name);
15475    }
15476    composeDomainResource(t, "MolecularSequence", name, element, index);
15477    for (int i = 0; i < element.getIdentifier().size(); i++) {
15478      composeIdentifier(t, "MolecularSequence", "identifier", element.getIdentifier().get(i), i);
15479    }
15480    if (element.hasTypeElement()) {
15481      composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1);
15482    }
15483    if (element.hasCoordinateSystemElement()) {
15484      composeInteger(t, "MolecularSequence", "coordinateSystem", element.getCoordinateSystemElement(), -1);
15485    }
15486    if (element.hasPatient()) {
15487      composeReference(t, "MolecularSequence", "patient", element.getPatient(), -1);
15488    }
15489    if (element.hasSpecimen()) {
15490      composeReference(t, "MolecularSequence", "specimen", element.getSpecimen(), -1);
15491    }
15492    if (element.hasDevice()) {
15493      composeReference(t, "MolecularSequence", "device", element.getDevice(), -1);
15494    }
15495    if (element.hasPerformer()) {
15496      composeReference(t, "MolecularSequence", "performer", element.getPerformer(), -1);
15497    }
15498    if (element.hasQuantity()) {
15499      composeQuantity(t, "MolecularSequence", "quantity", element.getQuantity(), -1);
15500    }
15501    if (element.hasReferenceSeq()) {
15502      composeMolecularSequenceReferenceSeqComponent(t, "MolecularSequence", "referenceSeq", element.getReferenceSeq(), -1);
15503    }
15504    for (int i = 0; i < element.getVariant().size(); i++) {
15505      composeMolecularSequenceVariantComponent(t, "MolecularSequence", "variant", element.getVariant().get(i), i);
15506    }
15507    if (element.hasObservedSeqElement()) {
15508      composeString(t, "MolecularSequence", "observedSeq", element.getObservedSeqElement(), -1);
15509    }
15510    for (int i = 0; i < element.getQuality().size(); i++) {
15511      composeMolecularSequenceQualityComponent(t, "MolecularSequence", "quality", element.getQuality().get(i), i);
15512    }
15513    if (element.hasReadCoverageElement()) {
15514      composeInteger(t, "MolecularSequence", "readCoverage", element.getReadCoverageElement(), -1);
15515    }
15516    for (int i = 0; i < element.getRepository().size(); i++) {
15517      composeMolecularSequenceRepositoryComponent(t, "MolecularSequence", "repository", element.getRepository().get(i), i);
15518    }
15519    for (int i = 0; i < element.getPointer().size(); i++) {
15520      composeReference(t, "MolecularSequence", "pointer", element.getPointer().get(i), i);
15521    }
15522    for (int i = 0; i < element.getStructureVariant().size(); i++) {
15523      composeMolecularSequenceStructureVariantComponent(t, "MolecularSequence", "structureVariant", element.getStructureVariant().get(i), i);
15524    }
15525  }
15526
15527  protected void composeMolecularSequenceReferenceSeqComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceReferenceSeqComponent element, int index) {
15528    if (element == null) 
15529      return;
15530    Complex t;
15531    if (Utilities.noString(parentType))
15532      t = parent;
15533    else {
15534      t = parent.predicate("fhir:"+parentType+'.'+name);
15535    }
15536    composeBackboneElement(t, "referenceSeq", name, element, index);
15537    if (element.hasChromosome()) {
15538      composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "chromosome", element.getChromosome(), -1);
15539    }
15540    if (element.hasGenomeBuildElement()) {
15541      composeString(t, "MolecularSequenceReferenceSeqComponent", "genomeBuild", element.getGenomeBuildElement(), -1);
15542    }
15543    if (element.hasOrientationElement()) {
15544      composeEnum(t, "MolecularSequenceReferenceSeqComponent", "orientation", element.getOrientationElement(), -1);
15545    }
15546    if (element.hasReferenceSeqId()) {
15547      composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqId", element.getReferenceSeqId(), -1);
15548    }
15549    if (element.hasReferenceSeqPointer()) {
15550      composeReference(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqPointer", element.getReferenceSeqPointer(), -1);
15551    }
15552    if (element.hasReferenceSeqStringElement()) {
15553      composeString(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqString", element.getReferenceSeqStringElement(), -1);
15554    }
15555    if (element.hasStrandElement()) {
15556      composeEnum(t, "MolecularSequenceReferenceSeqComponent", "strand", element.getStrandElement(), -1);
15557    }
15558    if (element.hasWindowStartElement()) {
15559      composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowStart", element.getWindowStartElement(), -1);
15560    }
15561    if (element.hasWindowEndElement()) {
15562      composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowEnd", element.getWindowEndElement(), -1);
15563    }
15564  }
15565
15566  protected void composeMolecularSequenceVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceVariantComponent element, int index) {
15567    if (element == null) 
15568      return;
15569    Complex t;
15570    if (Utilities.noString(parentType))
15571      t = parent;
15572    else {
15573      t = parent.predicate("fhir:"+parentType+'.'+name);
15574    }
15575    composeBackboneElement(t, "variant", name, element, index);
15576    if (element.hasStartElement()) {
15577      composeInteger(t, "MolecularSequenceVariantComponent", "start", element.getStartElement(), -1);
15578    }
15579    if (element.hasEndElement()) {
15580      composeInteger(t, "MolecularSequenceVariantComponent", "end", element.getEndElement(), -1);
15581    }
15582    if (element.hasObservedAlleleElement()) {
15583      composeString(t, "MolecularSequenceVariantComponent", "observedAllele", element.getObservedAlleleElement(), -1);
15584    }
15585    if (element.hasReferenceAlleleElement()) {
15586      composeString(t, "MolecularSequenceVariantComponent", "referenceAllele", element.getReferenceAlleleElement(), -1);
15587    }
15588    if (element.hasCigarElement()) {
15589      composeString(t, "MolecularSequenceVariantComponent", "cigar", element.getCigarElement(), -1);
15590    }
15591    if (element.hasVariantPointer()) {
15592      composeReference(t, "MolecularSequenceVariantComponent", "variantPointer", element.getVariantPointer(), -1);
15593    }
15594  }
15595
15596  protected void composeMolecularSequenceQualityComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityComponent element, int index) {
15597    if (element == null) 
15598      return;
15599    Complex t;
15600    if (Utilities.noString(parentType))
15601      t = parent;
15602    else {
15603      t = parent.predicate("fhir:"+parentType+'.'+name);
15604    }
15605    composeBackboneElement(t, "quality", name, element, index);
15606    if (element.hasTypeElement()) {
15607      composeEnum(t, "MolecularSequenceQualityComponent", "type", element.getTypeElement(), -1);
15608    }
15609    if (element.hasStandardSequence()) {
15610      composeCodeableConcept(t, "MolecularSequenceQualityComponent", "standardSequence", element.getStandardSequence(), -1);
15611    }
15612    if (element.hasStartElement()) {
15613      composeInteger(t, "MolecularSequenceQualityComponent", "start", element.getStartElement(), -1);
15614    }
15615    if (element.hasEndElement()) {
15616      composeInteger(t, "MolecularSequenceQualityComponent", "end", element.getEndElement(), -1);
15617    }
15618    if (element.hasScore()) {
15619      composeQuantity(t, "MolecularSequenceQualityComponent", "score", element.getScore(), -1);
15620    }
15621    if (element.hasMethod()) {
15622      composeCodeableConcept(t, "MolecularSequenceQualityComponent", "method", element.getMethod(), -1);
15623    }
15624    if (element.hasTruthTPElement()) {
15625      composeDecimal(t, "MolecularSequenceQualityComponent", "truthTP", element.getTruthTPElement(), -1);
15626    }
15627    if (element.hasQueryTPElement()) {
15628      composeDecimal(t, "MolecularSequenceQualityComponent", "queryTP", element.getQueryTPElement(), -1);
15629    }
15630    if (element.hasTruthFNElement()) {
15631      composeDecimal(t, "MolecularSequenceQualityComponent", "truthFN", element.getTruthFNElement(), -1);
15632    }
15633    if (element.hasQueryFPElement()) {
15634      composeDecimal(t, "MolecularSequenceQualityComponent", "queryFP", element.getQueryFPElement(), -1);
15635    }
15636    if (element.hasGtFPElement()) {
15637      composeDecimal(t, "MolecularSequenceQualityComponent", "gtFP", element.getGtFPElement(), -1);
15638    }
15639    if (element.hasPrecisionElement()) {
15640      composeDecimal(t, "MolecularSequenceQualityComponent", "precision", element.getPrecisionElement(), -1);
15641    }
15642    if (element.hasRecallElement()) {
15643      composeDecimal(t, "MolecularSequenceQualityComponent", "recall", element.getRecallElement(), -1);
15644    }
15645    if (element.hasFScoreElement()) {
15646      composeDecimal(t, "MolecularSequenceQualityComponent", "fScore", element.getFScoreElement(), -1);
15647    }
15648    if (element.hasRoc()) {
15649      composeMolecularSequenceQualityRocComponent(t, "MolecularSequenceQualityComponent", "roc", element.getRoc(), -1);
15650    }
15651  }
15652
15653  protected void composeMolecularSequenceQualityRocComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityRocComponent element, int index) {
15654    if (element == null) 
15655      return;
15656    Complex t;
15657    if (Utilities.noString(parentType))
15658      t = parent;
15659    else {
15660      t = parent.predicate("fhir:"+parentType+'.'+name);
15661    }
15662    composeBackboneElement(t, "roc", name, element, index);
15663    for (int i = 0; i < element.getScore().size(); i++) {
15664      composeInteger(t, "MolecularSequenceQualityRocComponent", "score", element.getScore().get(i), i);
15665    }
15666    for (int i = 0; i < element.getNumTP().size(); i++) {
15667      composeInteger(t, "MolecularSequenceQualityRocComponent", "numTP", element.getNumTP().get(i), i);
15668    }
15669    for (int i = 0; i < element.getNumFP().size(); i++) {
15670      composeInteger(t, "MolecularSequenceQualityRocComponent", "numFP", element.getNumFP().get(i), i);
15671    }
15672    for (int i = 0; i < element.getNumFN().size(); i++) {
15673      composeInteger(t, "MolecularSequenceQualityRocComponent", "numFN", element.getNumFN().get(i), i);
15674    }
15675    for (int i = 0; i < element.getPrecision().size(); i++) {
15676      composeDecimal(t, "MolecularSequenceQualityRocComponent", "precision", element.getPrecision().get(i), i);
15677    }
15678    for (int i = 0; i < element.getSensitivity().size(); i++) {
15679      composeDecimal(t, "MolecularSequenceQualityRocComponent", "sensitivity", element.getSensitivity().get(i), i);
15680    }
15681    for (int i = 0; i < element.getFMeasure().size(); i++) {
15682      composeDecimal(t, "MolecularSequenceQualityRocComponent", "fMeasure", element.getFMeasure().get(i), i);
15683    }
15684  }
15685
15686  protected void composeMolecularSequenceRepositoryComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRepositoryComponent element, int index) {
15687    if (element == null) 
15688      return;
15689    Complex t;
15690    if (Utilities.noString(parentType))
15691      t = parent;
15692    else {
15693      t = parent.predicate("fhir:"+parentType+'.'+name);
15694    }
15695    composeBackboneElement(t, "repository", name, element, index);
15696    if (element.hasTypeElement()) {
15697      composeEnum(t, "MolecularSequenceRepositoryComponent", "type", element.getTypeElement(), -1);
15698    }
15699    if (element.hasUrlElement()) {
15700      composeUri(t, "MolecularSequenceRepositoryComponent", "url", element.getUrlElement(), -1);
15701    }
15702    if (element.hasNameElement()) {
15703      composeString(t, "MolecularSequenceRepositoryComponent", "name", element.getNameElement(), -1);
15704    }
15705    if (element.hasDatasetIdElement()) {
15706      composeString(t, "MolecularSequenceRepositoryComponent", "datasetId", element.getDatasetIdElement(), -1);
15707    }
15708    if (element.hasVariantsetIdElement()) {
15709      composeString(t, "MolecularSequenceRepositoryComponent", "variantsetId", element.getVariantsetIdElement(), -1);
15710    }
15711    if (element.hasReadsetIdElement()) {
15712      composeString(t, "MolecularSequenceRepositoryComponent", "readsetId", element.getReadsetIdElement(), -1);
15713    }
15714  }
15715
15716  protected void composeMolecularSequenceStructureVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantComponent element, int index) {
15717    if (element == null) 
15718      return;
15719    Complex t;
15720    if (Utilities.noString(parentType))
15721      t = parent;
15722    else {
15723      t = parent.predicate("fhir:"+parentType+'.'+name);
15724    }
15725    composeBackboneElement(t, "structureVariant", name, element, index);
15726    if (element.hasVariantType()) {
15727      composeCodeableConcept(t, "MolecularSequenceStructureVariantComponent", "variantType", element.getVariantType(), -1);
15728    }
15729    if (element.hasExactElement()) {
15730      composeBoolean(t, "MolecularSequenceStructureVariantComponent", "exact", element.getExactElement(), -1);
15731    }
15732    if (element.hasLengthElement()) {
15733      composeInteger(t, "MolecularSequenceStructureVariantComponent", "length", element.getLengthElement(), -1);
15734    }
15735    if (element.hasOuter()) {
15736      composeMolecularSequenceStructureVariantOuterComponent(t, "MolecularSequenceStructureVariantComponent", "outer", element.getOuter(), -1);
15737    }
15738    if (element.hasInner()) {
15739      composeMolecularSequenceStructureVariantInnerComponent(t, "MolecularSequenceStructureVariantComponent", "inner", element.getInner(), -1);
15740    }
15741  }
15742
15743  protected void composeMolecularSequenceStructureVariantOuterComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantOuterComponent element, int index) {
15744    if (element == null) 
15745      return;
15746    Complex t;
15747    if (Utilities.noString(parentType))
15748      t = parent;
15749    else {
15750      t = parent.predicate("fhir:"+parentType+'.'+name);
15751    }
15752    composeBackboneElement(t, "outer", name, element, index);
15753    if (element.hasStartElement()) {
15754      composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "start", element.getStartElement(), -1);
15755    }
15756    if (element.hasEndElement()) {
15757      composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "end", element.getEndElement(), -1);
15758    }
15759  }
15760
15761  protected void composeMolecularSequenceStructureVariantInnerComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantInnerComponent element, int index) {
15762    if (element == null) 
15763      return;
15764    Complex t;
15765    if (Utilities.noString(parentType))
15766      t = parent;
15767    else {
15768      t = parent.predicate("fhir:"+parentType+'.'+name);
15769    }
15770    composeBackboneElement(t, "inner", name, element, index);
15771    if (element.hasStartElement()) {
15772      composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "start", element.getStartElement(), -1);
15773    }
15774    if (element.hasEndElement()) {
15775      composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "end", element.getEndElement(), -1);
15776    }
15777  }
15778
15779  protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) {
15780    if (element == null) 
15781      return;
15782    Complex t;
15783    if (Utilities.noString(parentType))
15784      t = parent;
15785    else {
15786      t = parent.predicate("fhir:"+parentType+'.'+name);
15787    }
15788    composeDomainResource(t, "NamingSystem", name, element, index);
15789    if (element.hasNameElement()) {
15790      composeString(t, "NamingSystem", "name", element.getNameElement(), -1);
15791    }
15792    if (element.hasStatusElement()) {
15793      composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1);
15794    }
15795    if (element.hasKindElement()) {
15796      composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1);
15797    }
15798    if (element.hasDateElement()) {
15799      composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1);
15800    }
15801    if (element.hasPublisherElement()) {
15802      composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1);
15803    }
15804    for (int i = 0; i < element.getContact().size(); i++) {
15805      composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i);
15806    }
15807    if (element.hasResponsibleElement()) {
15808      composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1);
15809    }
15810    if (element.hasType()) {
15811      composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1);
15812    }
15813    if (element.hasDescriptionElement()) {
15814      composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1);
15815    }
15816    for (int i = 0; i < element.getUseContext().size(); i++) {
15817      composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i);
15818    }
15819    for (int i = 0; i < element.getJurisdiction().size(); i++) {
15820      composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i);
15821    }
15822    if (element.hasUsageElement()) {
15823      composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1);
15824    }
15825    for (int i = 0; i < element.getUniqueId().size(); i++) {
15826      composeNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i);
15827    }
15828  }
15829
15830  protected void composeNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) {
15831    if (element == null) 
15832      return;
15833    Complex t;
15834    if (Utilities.noString(parentType))
15835      t = parent;
15836    else {
15837      t = parent.predicate("fhir:"+parentType+'.'+name);
15838    }
15839    composeBackboneElement(t, "uniqueId", name, element, index);
15840    if (element.hasTypeElement()) {
15841      composeEnum(t, "NamingSystemUniqueIdComponent", "type", element.getTypeElement(), -1);
15842    }
15843    if (element.hasValueElement()) {
15844      composeString(t, "NamingSystemUniqueIdComponent", "value", element.getValueElement(), -1);
15845    }
15846    if (element.hasPreferredElement()) {
15847      composeBoolean(t, "NamingSystemUniqueIdComponent", "preferred", element.getPreferredElement(), -1);
15848    }
15849    if (element.hasCommentElement()) {
15850      composeString(t, "NamingSystemUniqueIdComponent", "comment", element.getCommentElement(), -1);
15851    }
15852    if (element.hasPeriod()) {
15853      composePeriod(t, "NamingSystemUniqueIdComponent", "period", element.getPeriod(), -1);
15854    }
15855  }
15856
15857  protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) {
15858    if (element == null) 
15859      return;
15860    Complex t;
15861    if (Utilities.noString(parentType))
15862      t = parent;
15863    else {
15864      t = parent.predicate("fhir:"+parentType+'.'+name);
15865    }
15866    composeDomainResource(t, "NutritionOrder", name, element, index);
15867    for (int i = 0; i < element.getIdentifier().size(); i++) {
15868      composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i);
15869    }
15870    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
15871      composeCanonical(t, "NutritionOrder", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
15872    }
15873    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
15874      composeUri(t, "NutritionOrder", "instantiatesUri", element.getInstantiatesUri().get(i), i);
15875    }
15876    for (int i = 0; i < element.getInstantiates().size(); i++) {
15877      composeUri(t, "NutritionOrder", "instantiates", element.getInstantiates().get(i), i);
15878    }
15879    if (element.hasStatusElement()) {
15880      composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1);
15881    }
15882    if (element.hasIntentElement()) {
15883      composeEnum(t, "NutritionOrder", "intent", element.getIntentElement(), -1);
15884    }
15885    if (element.hasPatient()) {
15886      composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1);
15887    }
15888    if (element.hasEncounter()) {
15889      composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1);
15890    }
15891    if (element.hasDateTimeElement()) {
15892      composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1);
15893    }
15894    if (element.hasOrderer()) {
15895      composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1);
15896    }
15897    for (int i = 0; i < element.getAllergyIntolerance().size(); i++) {
15898      composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i);
15899    }
15900    for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) {
15901      composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i);
15902    }
15903    for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) {
15904      composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i);
15905    }
15906    if (element.hasOralDiet()) {
15907      composeNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1);
15908    }
15909    for (int i = 0; i < element.getSupplement().size(); i++) {
15910      composeNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i);
15911    }
15912    if (element.hasEnteralFormula()) {
15913      composeNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1);
15914    }
15915    for (int i = 0; i < element.getNote().size(); i++) {
15916      composeAnnotation(t, "NutritionOrder", "note", element.getNote().get(i), i);
15917    }
15918  }
15919
15920  protected void composeNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) {
15921    if (element == null) 
15922      return;
15923    Complex t;
15924    if (Utilities.noString(parentType))
15925      t = parent;
15926    else {
15927      t = parent.predicate("fhir:"+parentType+'.'+name);
15928    }
15929    composeBackboneElement(t, "oralDiet", name, element, index);
15930    for (int i = 0; i < element.getType().size(); i++) {
15931      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "type", element.getType().get(i), i);
15932    }
15933    for (int i = 0; i < element.getSchedule().size(); i++) {
15934      composeTiming(t, "NutritionOrderOralDietComponent", "schedule", element.getSchedule().get(i), i);
15935    }
15936    for (int i = 0; i < element.getNutrient().size(); i++) {
15937      composeNutritionOrderOralDietNutrientComponent(t, "NutritionOrderOralDietComponent", "nutrient", element.getNutrient().get(i), i);
15938    }
15939    for (int i = 0; i < element.getTexture().size(); i++) {
15940      composeNutritionOrderOralDietTextureComponent(t, "NutritionOrderOralDietComponent", "texture", element.getTexture().get(i), i);
15941    }
15942    for (int i = 0; i < element.getFluidConsistencyType().size(); i++) {
15943      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i);
15944    }
15945    if (element.hasInstructionElement()) {
15946      composeString(t, "NutritionOrderOralDietComponent", "instruction", element.getInstructionElement(), -1);
15947    }
15948  }
15949
15950  protected void composeNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) {
15951    if (element == null) 
15952      return;
15953    Complex t;
15954    if (Utilities.noString(parentType))
15955      t = parent;
15956    else {
15957      t = parent.predicate("fhir:"+parentType+'.'+name);
15958    }
15959    composeBackboneElement(t, "nutrient", name, element, index);
15960    if (element.hasModifier()) {
15961      composeCodeableConcept(t, "NutritionOrderOralDietNutrientComponent", "modifier", element.getModifier(), -1);
15962    }
15963    if (element.hasAmount()) {
15964      composeQuantity(t, "NutritionOrderOralDietNutrientComponent", "amount", element.getAmount(), -1);
15965    }
15966  }
15967
15968  protected void composeNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) {
15969    if (element == null) 
15970      return;
15971    Complex t;
15972    if (Utilities.noString(parentType))
15973      t = parent;
15974    else {
15975      t = parent.predicate("fhir:"+parentType+'.'+name);
15976    }
15977    composeBackboneElement(t, "texture", name, element, index);
15978    if (element.hasModifier()) {
15979      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "modifier", element.getModifier(), -1);
15980    }
15981    if (element.hasFoodType()) {
15982      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "foodType", element.getFoodType(), -1);
15983    }
15984  }
15985
15986  protected void composeNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) {
15987    if (element == null) 
15988      return;
15989    Complex t;
15990    if (Utilities.noString(parentType))
15991      t = parent;
15992    else {
15993      t = parent.predicate("fhir:"+parentType+'.'+name);
15994    }
15995    composeBackboneElement(t, "supplement", name, element, index);
15996    if (element.hasType()) {
15997      composeCodeableConcept(t, "NutritionOrderSupplementComponent", "type", element.getType(), -1);
15998    }
15999    if (element.hasProductNameElement()) {
16000      composeString(t, "NutritionOrderSupplementComponent", "productName", element.getProductNameElement(), -1);
16001    }
16002    for (int i = 0; i < element.getSchedule().size(); i++) {
16003      composeTiming(t, "NutritionOrderSupplementComponent", "schedule", element.getSchedule().get(i), i);
16004    }
16005    if (element.hasQuantity()) {
16006      composeQuantity(t, "NutritionOrderSupplementComponent", "quantity", element.getQuantity(), -1);
16007    }
16008    if (element.hasInstructionElement()) {
16009      composeString(t, "NutritionOrderSupplementComponent", "instruction", element.getInstructionElement(), -1);
16010    }
16011  }
16012
16013  protected void composeNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) {
16014    if (element == null) 
16015      return;
16016    Complex t;
16017    if (Utilities.noString(parentType))
16018      t = parent;
16019    else {
16020      t = parent.predicate("fhir:"+parentType+'.'+name);
16021    }
16022    composeBackboneElement(t, "enteralFormula", name, element, index);
16023    if (element.hasBaseFormulaType()) {
16024      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaType", element.getBaseFormulaType(), -1);
16025    }
16026    if (element.hasBaseFormulaProductNameElement()) {
16027      composeString(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1);
16028    }
16029    if (element.hasAdditiveType()) {
16030      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "additiveType", element.getAdditiveType(), -1);
16031    }
16032    if (element.hasAdditiveProductNameElement()) {
16033      composeString(t, "NutritionOrderEnteralFormulaComponent", "additiveProductName", element.getAdditiveProductNameElement(), -1);
16034    }
16035    if (element.hasCaloricDensity()) {
16036      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "caloricDensity", element.getCaloricDensity(), -1);
16037    }
16038    if (element.hasRouteofAdministration()) {
16039      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "routeofAdministration", element.getRouteofAdministration(), -1);
16040    }
16041    for (int i = 0; i < element.getAdministration().size(); i++) {
16042      composeNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrderEnteralFormulaComponent", "administration", element.getAdministration().get(i), i);
16043    }
16044    if (element.hasMaxVolumeToDeliver()) {
16045      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1);
16046    }
16047    if (element.hasAdministrationInstructionElement()) {
16048      composeString(t, "NutritionOrderEnteralFormulaComponent", "administrationInstruction", element.getAdministrationInstructionElement(), -1);
16049    }
16050  }
16051
16052  protected void composeNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) {
16053    if (element == null) 
16054      return;
16055    Complex t;
16056    if (Utilities.noString(parentType))
16057      t = parent;
16058    else {
16059      t = parent.predicate("fhir:"+parentType+'.'+name);
16060    }
16061    composeBackboneElement(t, "administration", name, element, index);
16062    if (element.hasSchedule()) {
16063      composeTiming(t, "NutritionOrderEnteralFormulaAdministrationComponent", "schedule", element.getSchedule(), -1);
16064    }
16065    if (element.hasQuantity()) {
16066      composeQuantity(t, "NutritionOrderEnteralFormulaAdministrationComponent", "quantity", element.getQuantity(), -1);
16067    }
16068    if (element.hasRate()) {
16069      composeType(t, "NutritionOrderEnteralFormulaAdministrationComponent", "rate", element.getRate(), -1);
16070    }
16071  }
16072
16073  protected void composeNutritionProduct(Complex parent, String parentType, String name, NutritionProduct element, int index) {
16074    if (element == null) 
16075      return;
16076    Complex t;
16077    if (Utilities.noString(parentType))
16078      t = parent;
16079    else {
16080      t = parent.predicate("fhir:"+parentType+'.'+name);
16081    }
16082    composeDomainResource(t, "NutritionProduct", name, element, index);
16083    if (element.hasStatusElement()) {
16084      composeEnum(t, "NutritionProduct", "status", element.getStatusElement(), -1);
16085    }
16086    for (int i = 0; i < element.getCategory().size(); i++) {
16087      composeCodeableConcept(t, "NutritionProduct", "category", element.getCategory().get(i), i);
16088    }
16089    if (element.hasCode()) {
16090      composeCodeableConcept(t, "NutritionProduct", "code", element.getCode(), -1);
16091    }
16092    for (int i = 0; i < element.getManufacturer().size(); i++) {
16093      composeReference(t, "NutritionProduct", "manufacturer", element.getManufacturer().get(i), i);
16094    }
16095    for (int i = 0; i < element.getNutrient().size(); i++) {
16096      composeNutritionProductNutrientComponent(t, "NutritionProduct", "nutrient", element.getNutrient().get(i), i);
16097    }
16098    for (int i = 0; i < element.getIngredient().size(); i++) {
16099      composeNutritionProductIngredientComponent(t, "NutritionProduct", "ingredient", element.getIngredient().get(i), i);
16100    }
16101    for (int i = 0; i < element.getKnownAllergen().size(); i++) {
16102      composeCodeableReference(t, "NutritionProduct", "knownAllergen", element.getKnownAllergen().get(i), i);
16103    }
16104    for (int i = 0; i < element.getProductCharacteristic().size(); i++) {
16105      composeNutritionProductProductCharacteristicComponent(t, "NutritionProduct", "productCharacteristic", element.getProductCharacteristic().get(i), i);
16106    }
16107    if (element.hasInstance()) {
16108      composeNutritionProductInstanceComponent(t, "NutritionProduct", "instance", element.getInstance(), -1);
16109    }
16110    for (int i = 0; i < element.getNote().size(); i++) {
16111      composeAnnotation(t, "NutritionProduct", "note", element.getNote().get(i), i);
16112    }
16113  }
16114
16115  protected void composeNutritionProductNutrientComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductNutrientComponent element, int index) {
16116    if (element == null) 
16117      return;
16118    Complex t;
16119    if (Utilities.noString(parentType))
16120      t = parent;
16121    else {
16122      t = parent.predicate("fhir:"+parentType+'.'+name);
16123    }
16124    composeBackboneElement(t, "nutrient", name, element, index);
16125    if (element.hasItem()) {
16126      composeCodeableReference(t, "NutritionProductNutrientComponent", "item", element.getItem(), -1);
16127    }
16128    for (int i = 0; i < element.getAmount().size(); i++) {
16129      composeRatio(t, "NutritionProductNutrientComponent", "amount", element.getAmount().get(i), i);
16130    }
16131  }
16132
16133  protected void composeNutritionProductIngredientComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductIngredientComponent element, int index) {
16134    if (element == null) 
16135      return;
16136    Complex t;
16137    if (Utilities.noString(parentType))
16138      t = parent;
16139    else {
16140      t = parent.predicate("fhir:"+parentType+'.'+name);
16141    }
16142    composeBackboneElement(t, "ingredient", name, element, index);
16143    if (element.hasItem()) {
16144      composeCodeableReference(t, "NutritionProductIngredientComponent", "item", element.getItem(), -1);
16145    }
16146    for (int i = 0; i < element.getAmount().size(); i++) {
16147      composeRatio(t, "NutritionProductIngredientComponent", "amount", element.getAmount().get(i), i);
16148    }
16149  }
16150
16151  protected void composeNutritionProductProductCharacteristicComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductProductCharacteristicComponent element, int index) {
16152    if (element == null) 
16153      return;
16154    Complex t;
16155    if (Utilities.noString(parentType))
16156      t = parent;
16157    else {
16158      t = parent.predicate("fhir:"+parentType+'.'+name);
16159    }
16160    composeBackboneElement(t, "productCharacteristic", name, element, index);
16161    if (element.hasType()) {
16162      composeCodeableConcept(t, "NutritionProductProductCharacteristicComponent", "type", element.getType(), -1);
16163    }
16164    if (element.hasValue()) {
16165      composeType(t, "NutritionProductProductCharacteristicComponent", "value", element.getValue(), -1);
16166    }
16167  }
16168
16169  protected void composeNutritionProductInstanceComponent(Complex parent, String parentType, String name, NutritionProduct.NutritionProductInstanceComponent element, int index) {
16170    if (element == null) 
16171      return;
16172    Complex t;
16173    if (Utilities.noString(parentType))
16174      t = parent;
16175    else {
16176      t = parent.predicate("fhir:"+parentType+'.'+name);
16177    }
16178    composeBackboneElement(t, "instance", name, element, index);
16179    if (element.hasQuantity()) {
16180      composeQuantity(t, "NutritionProductInstanceComponent", "quantity", element.getQuantity(), -1);
16181    }
16182    for (int i = 0; i < element.getIdentifier().size(); i++) {
16183      composeIdentifier(t, "NutritionProductInstanceComponent", "identifier", element.getIdentifier().get(i), i);
16184    }
16185    if (element.hasLotNumberElement()) {
16186      composeString(t, "NutritionProductInstanceComponent", "lotNumber", element.getLotNumberElement(), -1);
16187    }
16188    if (element.hasExpiryElement()) {
16189      composeDateTime(t, "NutritionProductInstanceComponent", "expiry", element.getExpiryElement(), -1);
16190    }
16191    if (element.hasUseByElement()) {
16192      composeDateTime(t, "NutritionProductInstanceComponent", "useBy", element.getUseByElement(), -1);
16193    }
16194  }
16195
16196  protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) {
16197    if (element == null) 
16198      return;
16199    Complex t;
16200    if (Utilities.noString(parentType))
16201      t = parent;
16202    else {
16203      t = parent.predicate("fhir:"+parentType+'.'+name);
16204    }
16205    composeDomainResource(t, "Observation", name, element, index);
16206    for (int i = 0; i < element.getIdentifier().size(); i++) {
16207      composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i);
16208    }
16209    for (int i = 0; i < element.getBasedOn().size(); i++) {
16210      composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i);
16211    }
16212    for (int i = 0; i < element.getPartOf().size(); i++) {
16213      composeReference(t, "Observation", "partOf", element.getPartOf().get(i), i);
16214    }
16215    if (element.hasStatusElement()) {
16216      composeEnum(t, "Observation", "status", element.getStatusElement(), -1);
16217    }
16218    for (int i = 0; i < element.getCategory().size(); i++) {
16219      composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i);
16220    }
16221    if (element.hasCode()) {
16222      composeCodeableConcept(t, "Observation", "code", element.getCode(), -1);
16223    }
16224    if (element.hasSubject()) {
16225      composeReference(t, "Observation", "subject", element.getSubject(), -1);
16226    }
16227    for (int i = 0; i < element.getFocus().size(); i++) {
16228      composeReference(t, "Observation", "focus", element.getFocus().get(i), i);
16229    }
16230    if (element.hasEncounter()) {
16231      composeReference(t, "Observation", "encounter", element.getEncounter(), -1);
16232    }
16233    if (element.hasEffective()) {
16234      composeType(t, "Observation", "effective", element.getEffective(), -1);
16235    }
16236    if (element.hasIssuedElement()) {
16237      composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1);
16238    }
16239    for (int i = 0; i < element.getPerformer().size(); i++) {
16240      composeReference(t, "Observation", "performer", element.getPerformer().get(i), i);
16241    }
16242    if (element.hasValue()) {
16243      composeType(t, "Observation", "value", element.getValue(), -1);
16244    }
16245    if (element.hasDataAbsentReason()) {
16246      composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1);
16247    }
16248    for (int i = 0; i < element.getInterpretation().size(); i++) {
16249      composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i);
16250    }
16251    for (int i = 0; i < element.getNote().size(); i++) {
16252      composeAnnotation(t, "Observation", "note", element.getNote().get(i), i);
16253    }
16254    if (element.hasBodySite()) {
16255      composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1);
16256    }
16257    if (element.hasMethod()) {
16258      composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1);
16259    }
16260    if (element.hasSpecimen()) {
16261      composeReference(t, "Observation", "specimen", element.getSpecimen(), -1);
16262    }
16263    if (element.hasDevice()) {
16264      composeReference(t, "Observation", "device", element.getDevice(), -1);
16265    }
16266    for (int i = 0; i < element.getReferenceRange().size(); i++) {
16267      composeObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i);
16268    }
16269    for (int i = 0; i < element.getHasMember().size(); i++) {
16270      composeReference(t, "Observation", "hasMember", element.getHasMember().get(i), i);
16271    }
16272    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
16273      composeReference(t, "Observation", "derivedFrom", element.getDerivedFrom().get(i), i);
16274    }
16275    for (int i = 0; i < element.getComponent().size(); i++) {
16276      composeObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i);
16277    }
16278  }
16279
16280  protected void composeObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) {
16281    if (element == null) 
16282      return;
16283    Complex t;
16284    if (Utilities.noString(parentType))
16285      t = parent;
16286    else {
16287      t = parent.predicate("fhir:"+parentType+'.'+name);
16288    }
16289    composeBackboneElement(t, "referenceRange", name, element, index);
16290    if (element.hasLow()) {
16291      composeQuantity(t, "ObservationReferenceRangeComponent", "low", element.getLow(), -1);
16292    }
16293    if (element.hasHigh()) {
16294      composeQuantity(t, "ObservationReferenceRangeComponent", "high", element.getHigh(), -1);
16295    }
16296    if (element.hasType()) {
16297      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "type", element.getType(), -1);
16298    }
16299    for (int i = 0; i < element.getAppliesTo().size(); i++) {
16300      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "appliesTo", element.getAppliesTo().get(i), i);
16301    }
16302    if (element.hasAge()) {
16303      composeRange(t, "ObservationReferenceRangeComponent", "age", element.getAge(), -1);
16304    }
16305    if (element.hasTextElement()) {
16306      composeString(t, "ObservationReferenceRangeComponent", "text", element.getTextElement(), -1);
16307    }
16308  }
16309
16310  protected void composeObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) {
16311    if (element == null) 
16312      return;
16313    Complex t;
16314    if (Utilities.noString(parentType))
16315      t = parent;
16316    else {
16317      t = parent.predicate("fhir:"+parentType+'.'+name);
16318    }
16319    composeBackboneElement(t, "component", name, element, index);
16320    if (element.hasCode()) {
16321      composeCodeableConcept(t, "ObservationComponentComponent", "code", element.getCode(), -1);
16322    }
16323    if (element.hasValue()) {
16324      composeType(t, "ObservationComponentComponent", "value", element.getValue(), -1);
16325    }
16326    if (element.hasDataAbsentReason()) {
16327      composeCodeableConcept(t, "ObservationComponentComponent", "dataAbsentReason", element.getDataAbsentReason(), -1);
16328    }
16329    for (int i = 0; i < element.getInterpretation().size(); i++) {
16330      composeCodeableConcept(t, "ObservationComponentComponent", "interpretation", element.getInterpretation().get(i), i);
16331    }
16332    for (int i = 0; i < element.getReferenceRange().size(); i++) {
16333      composeObservationReferenceRangeComponent(t, "ObservationComponentComponent", "referenceRange", element.getReferenceRange().get(i), i);
16334    }
16335  }
16336
16337  protected void composeObservationDefinition(Complex parent, String parentType, String name, ObservationDefinition element, int index) {
16338    if (element == null) 
16339      return;
16340    Complex t;
16341    if (Utilities.noString(parentType))
16342      t = parent;
16343    else {
16344      t = parent.predicate("fhir:"+parentType+'.'+name);
16345    }
16346    composeDomainResource(t, "ObservationDefinition", name, element, index);
16347    for (int i = 0; i < element.getCategory().size(); i++) {
16348      composeCodeableConcept(t, "ObservationDefinition", "category", element.getCategory().get(i), i);
16349    }
16350    if (element.hasCode()) {
16351      composeCodeableConcept(t, "ObservationDefinition", "code", element.getCode(), -1);
16352    }
16353    for (int i = 0; i < element.getIdentifier().size(); i++) {
16354      composeIdentifier(t, "ObservationDefinition", "identifier", element.getIdentifier().get(i), i);
16355    }
16356    for (int i = 0; i < element.getPermittedDataType().size(); i++) {
16357      composeEnum(t, "ObservationDefinition", "permittedDataType", element.getPermittedDataType().get(i), i);
16358    }
16359    if (element.hasMultipleResultsAllowedElement()) {
16360      composeBoolean(t, "ObservationDefinition", "multipleResultsAllowed", element.getMultipleResultsAllowedElement(), -1);
16361    }
16362    if (element.hasMethod()) {
16363      composeCodeableConcept(t, "ObservationDefinition", "method", element.getMethod(), -1);
16364    }
16365    if (element.hasPreferredReportNameElement()) {
16366      composeString(t, "ObservationDefinition", "preferredReportName", element.getPreferredReportNameElement(), -1);
16367    }
16368    if (element.hasQuantitativeDetails()) {
16369      composeObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinition", "quantitativeDetails", element.getQuantitativeDetails(), -1);
16370    }
16371    for (int i = 0; i < element.getQualifiedInterval().size(); i++) {
16372      composeObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinition", "qualifiedInterval", element.getQualifiedInterval().get(i), i);
16373    }
16374    if (element.hasValidCodedValueSet()) {
16375      composeReference(t, "ObservationDefinition", "validCodedValueSet", element.getValidCodedValueSet(), -1);
16376    }
16377    if (element.hasNormalCodedValueSet()) {
16378      composeReference(t, "ObservationDefinition", "normalCodedValueSet", element.getNormalCodedValueSet(), -1);
16379    }
16380    if (element.hasAbnormalCodedValueSet()) {
16381      composeReference(t, "ObservationDefinition", "abnormalCodedValueSet", element.getAbnormalCodedValueSet(), -1);
16382    }
16383    if (element.hasCriticalCodedValueSet()) {
16384      composeReference(t, "ObservationDefinition", "criticalCodedValueSet", element.getCriticalCodedValueSet(), -1);
16385    }
16386  }
16387
16388  protected void composeObservationDefinitionQuantitativeDetailsComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQuantitativeDetailsComponent element, int index) {
16389    if (element == null) 
16390      return;
16391    Complex t;
16392    if (Utilities.noString(parentType))
16393      t = parent;
16394    else {
16395      t = parent.predicate("fhir:"+parentType+'.'+name);
16396    }
16397    composeBackboneElement(t, "quantitativeDetails", name, element, index);
16398    if (element.hasCustomaryUnit()) {
16399      composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "customaryUnit", element.getCustomaryUnit(), -1);
16400    }
16401    if (element.hasUnit()) {
16402      composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "unit", element.getUnit(), -1);
16403    }
16404    if (element.hasConversionFactorElement()) {
16405      composeDecimal(t, "ObservationDefinitionQuantitativeDetailsComponent", "conversionFactor", element.getConversionFactorElement(), -1);
16406    }
16407    if (element.hasDecimalPrecisionElement()) {
16408      composeInteger(t, "ObservationDefinitionQuantitativeDetailsComponent", "decimalPrecision", element.getDecimalPrecisionElement(), -1);
16409    }
16410  }
16411
16412  protected void composeObservationDefinitionQualifiedIntervalComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQualifiedIntervalComponent element, int index) {
16413    if (element == null) 
16414      return;
16415    Complex t;
16416    if (Utilities.noString(parentType))
16417      t = parent;
16418    else {
16419      t = parent.predicate("fhir:"+parentType+'.'+name);
16420    }
16421    composeBackboneElement(t, "qualifiedInterval", name, element, index);
16422    if (element.hasCategoryElement()) {
16423      composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "category", element.getCategoryElement(), -1);
16424    }
16425    if (element.hasRange()) {
16426      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "range", element.getRange(), -1);
16427    }
16428    if (element.hasContext()) {
16429      composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "context", element.getContext(), -1);
16430    }
16431    for (int i = 0; i < element.getAppliesTo().size(); i++) {
16432      composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "appliesTo", element.getAppliesTo().get(i), i);
16433    }
16434    if (element.hasGenderElement()) {
16435      composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "gender", element.getGenderElement(), -1);
16436    }
16437    if (element.hasAge()) {
16438      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "age", element.getAge(), -1);
16439    }
16440    if (element.hasGestationalAge()) {
16441      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "gestationalAge", element.getGestationalAge(), -1);
16442    }
16443    if (element.hasConditionElement()) {
16444      composeString(t, "ObservationDefinitionQualifiedIntervalComponent", "condition", element.getConditionElement(), -1);
16445    }
16446  }
16447
16448  protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) {
16449    if (element == null) 
16450      return;
16451    Complex t;
16452    if (Utilities.noString(parentType))
16453      t = parent;
16454    else {
16455      t = parent.predicate("fhir:"+parentType+'.'+name);
16456    }
16457    composeDomainResource(t, "OperationDefinition", name, element, index);
16458    if (element.hasUrlElement()) {
16459      composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1);
16460    }
16461    if (element.hasVersionElement()) {
16462      composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1);
16463    }
16464    if (element.hasNameElement()) {
16465      composeString(t, "OperationDefinition", "name", element.getNameElement(), -1);
16466    }
16467    if (element.hasTitleElement()) {
16468      composeString(t, "OperationDefinition", "title", element.getTitleElement(), -1);
16469    }
16470    if (element.hasStatusElement()) {
16471      composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1);
16472    }
16473    if (element.hasKindElement()) {
16474      composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1);
16475    }
16476    if (element.hasExperimentalElement()) {
16477      composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1);
16478    }
16479    if (element.hasDateElement()) {
16480      composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1);
16481    }
16482    if (element.hasPublisherElement()) {
16483      composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1);
16484    }
16485    for (int i = 0; i < element.getContact().size(); i++) {
16486      composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i);
16487    }
16488    if (element.hasDescriptionElement()) {
16489      composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1);
16490    }
16491    for (int i = 0; i < element.getUseContext().size(); i++) {
16492      composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i);
16493    }
16494    for (int i = 0; i < element.getJurisdiction().size(); i++) {
16495      composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
16496    }
16497    if (element.hasPurposeElement()) {
16498      composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1);
16499    }
16500    if (element.hasAffectsStateElement()) {
16501      composeBoolean(t, "OperationDefinition", "affectsState", element.getAffectsStateElement(), -1);
16502    }
16503    if (element.hasCodeElement()) {
16504      composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1);
16505    }
16506    if (element.hasCommentElement()) {
16507      composeMarkdown(t, "OperationDefinition", "comment", element.getCommentElement(), -1);
16508    }
16509    if (element.hasBaseElement()) {
16510      composeCanonical(t, "OperationDefinition", "base", element.getBaseElement(), -1);
16511    }
16512    for (int i = 0; i < element.getResource().size(); i++) {
16513      composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i);
16514    }
16515    if (element.hasSystemElement()) {
16516      composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1);
16517    }
16518    if (element.hasTypeElement()) {
16519      composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1);
16520    }
16521    if (element.hasInstanceElement()) {
16522      composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1);
16523    }
16524    if (element.hasInputProfileElement()) {
16525      composeCanonical(t, "OperationDefinition", "inputProfile", element.getInputProfileElement(), -1);
16526    }
16527    if (element.hasOutputProfileElement()) {
16528      composeCanonical(t, "OperationDefinition", "outputProfile", element.getOutputProfileElement(), -1);
16529    }
16530    for (int i = 0; i < element.getParameter().size(); i++) {
16531      composeOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i);
16532    }
16533    for (int i = 0; i < element.getOverload().size(); i++) {
16534      composeOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i);
16535    }
16536  }
16537
16538  protected void composeOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) {
16539    if (element == null) 
16540      return;
16541    Complex t;
16542    if (Utilities.noString(parentType))
16543      t = parent;
16544    else {
16545      t = parent.predicate("fhir:"+parentType+'.'+name);
16546    }
16547    composeBackboneElement(t, "parameter", name, element, index);
16548    if (element.hasNameElement()) {
16549      composeCode(t, "OperationDefinitionParameterComponent", "name", element.getNameElement(), -1);
16550    }
16551    if (element.hasUseElement()) {
16552      composeEnum(t, "OperationDefinitionParameterComponent", "use", element.getUseElement(), -1);
16553    }
16554    if (element.hasMinElement()) {
16555      composeInteger(t, "OperationDefinitionParameterComponent", "min", element.getMinElement(), -1);
16556    }
16557    if (element.hasMaxElement()) {
16558      composeString(t, "OperationDefinitionParameterComponent", "max", element.getMaxElement(), -1);
16559    }
16560    if (element.hasDocumentationElement()) {
16561      composeString(t, "OperationDefinitionParameterComponent", "documentation", element.getDocumentationElement(), -1);
16562    }
16563    if (element.hasTypeElement()) {
16564      composeEnum(t, "OperationDefinitionParameterComponent", "type", element.getTypeElement(), -1);
16565    }
16566    for (int i = 0; i < element.getTargetProfile().size(); i++) {
16567      composeCanonical(t, "OperationDefinitionParameterComponent", "targetProfile", element.getTargetProfile().get(i), i);
16568    }
16569    if (element.hasSearchTypeElement()) {
16570      composeEnum(t, "OperationDefinitionParameterComponent", "searchType", element.getSearchTypeElement(), -1);
16571    }
16572    if (element.hasBinding()) {
16573      composeOperationDefinitionParameterBindingComponent(t, "OperationDefinitionParameterComponent", "binding", element.getBinding(), -1);
16574    }
16575    for (int i = 0; i < element.getReferencedFrom().size(); i++) {
16576      composeOperationDefinitionParameterReferencedFromComponent(t, "OperationDefinitionParameterComponent", "referencedFrom", element.getReferencedFrom().get(i), i);
16577    }
16578    for (int i = 0; i < element.getPart().size(); i++) {
16579      composeOperationDefinitionParameterComponent(t, "OperationDefinitionParameterComponent", "part", element.getPart().get(i), i);
16580    }
16581  }
16582
16583  protected void composeOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) {
16584    if (element == null) 
16585      return;
16586    Complex t;
16587    if (Utilities.noString(parentType))
16588      t = parent;
16589    else {
16590      t = parent.predicate("fhir:"+parentType+'.'+name);
16591    }
16592    composeBackboneElement(t, "binding", name, element, index);
16593    if (element.hasStrengthElement()) {
16594      composeEnum(t, "OperationDefinitionParameterBindingComponent", "strength", element.getStrengthElement(), -1);
16595    }
16596    if (element.hasValueSetElement()) {
16597      composeCanonical(t, "OperationDefinitionParameterBindingComponent", "valueSet", element.getValueSetElement(), -1);
16598    }
16599  }
16600
16601  protected void composeOperationDefinitionParameterReferencedFromComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterReferencedFromComponent element, int index) {
16602    if (element == null) 
16603      return;
16604    Complex t;
16605    if (Utilities.noString(parentType))
16606      t = parent;
16607    else {
16608      t = parent.predicate("fhir:"+parentType+'.'+name);
16609    }
16610    composeBackboneElement(t, "referencedFrom", name, element, index);
16611    if (element.hasSourceElement()) {
16612      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "source", element.getSourceElement(), -1);
16613    }
16614    if (element.hasSourceIdElement()) {
16615      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "sourceId", element.getSourceIdElement(), -1);
16616    }
16617  }
16618
16619  protected void composeOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) {
16620    if (element == null) 
16621      return;
16622    Complex t;
16623    if (Utilities.noString(parentType))
16624      t = parent;
16625    else {
16626      t = parent.predicate("fhir:"+parentType+'.'+name);
16627    }
16628    composeBackboneElement(t, "overload", name, element, index);
16629    for (int i = 0; i < element.getParameterName().size(); i++) {
16630      composeString(t, "OperationDefinitionOverloadComponent", "parameterName", element.getParameterName().get(i), i);
16631    }
16632    if (element.hasCommentElement()) {
16633      composeString(t, "OperationDefinitionOverloadComponent", "comment", element.getCommentElement(), -1);
16634    }
16635  }
16636
16637  protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) {
16638    if (element == null) 
16639      return;
16640    Complex t;
16641    if (Utilities.noString(parentType))
16642      t = parent;
16643    else {
16644      t = parent.predicate("fhir:"+parentType+'.'+name);
16645    }
16646    composeDomainResource(t, "OperationOutcome", name, element, index);
16647    for (int i = 0; i < element.getIssue().size(); i++) {
16648      composeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i);
16649    }
16650  }
16651
16652  protected void composeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) {
16653    if (element == null) 
16654      return;
16655    Complex t;
16656    if (Utilities.noString(parentType))
16657      t = parent;
16658    else {
16659      t = parent.predicate("fhir:"+parentType+'.'+name);
16660    }
16661    composeBackboneElement(t, "issue", name, element, index);
16662    if (element.hasSeverityElement()) {
16663      composeEnum(t, "OperationOutcomeIssueComponent", "severity", element.getSeverityElement(), -1);
16664    }
16665    if (element.hasCodeElement()) {
16666      composeEnum(t, "OperationOutcomeIssueComponent", "code", element.getCodeElement(), -1);
16667    }
16668    if (element.hasDetails()) {
16669      composeCodeableConcept(t, "OperationOutcomeIssueComponent", "details", element.getDetails(), -1);
16670    }
16671    if (element.hasDiagnosticsElement()) {
16672      composeString(t, "OperationOutcomeIssueComponent", "diagnostics", element.getDiagnosticsElement(), -1);
16673    }
16674    for (int i = 0; i < element.getLocation().size(); i++) {
16675      composeString(t, "OperationOutcomeIssueComponent", "location", element.getLocation().get(i), i);
16676    }
16677    for (int i = 0; i < element.getExpression().size(); i++) {
16678      composeString(t, "OperationOutcomeIssueComponent", "expression", element.getExpression().get(i), i);
16679    }
16680  }
16681
16682  protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) {
16683    if (element == null) 
16684      return;
16685    Complex t;
16686    if (Utilities.noString(parentType))
16687      t = parent;
16688    else {
16689      t = parent.predicate("fhir:"+parentType+'.'+name);
16690    }
16691    composeDomainResource(t, "Organization", name, element, index);
16692    for (int i = 0; i < element.getIdentifier().size(); i++) {
16693      composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i);
16694    }
16695    if (element.hasActiveElement()) {
16696      composeBoolean(t, "Organization", "active", element.getActiveElement(), -1);
16697    }
16698    for (int i = 0; i < element.getType().size(); i++) {
16699      composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i);
16700    }
16701    if (element.hasNameElement()) {
16702      composeString(t, "Organization", "name", element.getNameElement(), -1);
16703    }
16704    for (int i = 0; i < element.getAlias().size(); i++) {
16705      composeString(t, "Organization", "alias", element.getAlias().get(i), i);
16706    }
16707    for (int i = 0; i < element.getTelecom().size(); i++) {
16708      composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i);
16709    }
16710    for (int i = 0; i < element.getAddress().size(); i++) {
16711      composeAddress(t, "Organization", "address", element.getAddress().get(i), i);
16712    }
16713    if (element.hasPartOf()) {
16714      composeReference(t, "Organization", "partOf", element.getPartOf(), -1);
16715    }
16716    for (int i = 0; i < element.getContact().size(); i++) {
16717      composeOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i);
16718    }
16719    for (int i = 0; i < element.getEndpoint().size(); i++) {
16720      composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i);
16721    }
16722  }
16723
16724  protected void composeOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) {
16725    if (element == null) 
16726      return;
16727    Complex t;
16728    if (Utilities.noString(parentType))
16729      t = parent;
16730    else {
16731      t = parent.predicate("fhir:"+parentType+'.'+name);
16732    }
16733    composeBackboneElement(t, "contact", name, element, index);
16734    if (element.hasPurpose()) {
16735      composeCodeableConcept(t, "OrganizationContactComponent", "purpose", element.getPurpose(), -1);
16736    }
16737    if (element.hasName()) {
16738      composeHumanName(t, "OrganizationContactComponent", "name", element.getName(), -1);
16739    }
16740    for (int i = 0; i < element.getTelecom().size(); i++) {
16741      composeContactPoint(t, "OrganizationContactComponent", "telecom", element.getTelecom().get(i), i);
16742    }
16743    if (element.hasAddress()) {
16744      composeAddress(t, "OrganizationContactComponent", "address", element.getAddress(), -1);
16745    }
16746  }
16747
16748  protected void composeOrganizationAffiliation(Complex parent, String parentType, String name, OrganizationAffiliation element, int index) {
16749    if (element == null) 
16750      return;
16751    Complex t;
16752    if (Utilities.noString(parentType))
16753      t = parent;
16754    else {
16755      t = parent.predicate("fhir:"+parentType+'.'+name);
16756    }
16757    composeDomainResource(t, "OrganizationAffiliation", name, element, index);
16758    for (int i = 0; i < element.getIdentifier().size(); i++) {
16759      composeIdentifier(t, "OrganizationAffiliation", "identifier", element.getIdentifier().get(i), i);
16760    }
16761    if (element.hasActiveElement()) {
16762      composeBoolean(t, "OrganizationAffiliation", "active", element.getActiveElement(), -1);
16763    }
16764    if (element.hasPeriod()) {
16765      composePeriod(t, "OrganizationAffiliation", "period", element.getPeriod(), -1);
16766    }
16767    if (element.hasOrganization()) {
16768      composeReference(t, "OrganizationAffiliation", "organization", element.getOrganization(), -1);
16769    }
16770    if (element.hasParticipatingOrganization()) {
16771      composeReference(t, "OrganizationAffiliation", "participatingOrganization", element.getParticipatingOrganization(), -1);
16772    }
16773    for (int i = 0; i < element.getNetwork().size(); i++) {
16774      composeReference(t, "OrganizationAffiliation", "network", element.getNetwork().get(i), i);
16775    }
16776    for (int i = 0; i < element.getCode().size(); i++) {
16777      composeCodeableConcept(t, "OrganizationAffiliation", "code", element.getCode().get(i), i);
16778    }
16779    for (int i = 0; i < element.getSpecialty().size(); i++) {
16780      composeCodeableConcept(t, "OrganizationAffiliation", "specialty", element.getSpecialty().get(i), i);
16781    }
16782    for (int i = 0; i < element.getLocation().size(); i++) {
16783      composeReference(t, "OrganizationAffiliation", "location", element.getLocation().get(i), i);
16784    }
16785    for (int i = 0; i < element.getHealthcareService().size(); i++) {
16786      composeReference(t, "OrganizationAffiliation", "healthcareService", element.getHealthcareService().get(i), i);
16787    }
16788    for (int i = 0; i < element.getTelecom().size(); i++) {
16789      composeContactPoint(t, "OrganizationAffiliation", "telecom", element.getTelecom().get(i), i);
16790    }
16791    for (int i = 0; i < element.getEndpoint().size(); i++) {
16792      composeReference(t, "OrganizationAffiliation", "endpoint", element.getEndpoint().get(i), i);
16793    }
16794  }
16795
16796  protected void composePackagedProductDefinition(Complex parent, String parentType, String name, PackagedProductDefinition element, int index) {
16797    if (element == null) 
16798      return;
16799    Complex t;
16800    if (Utilities.noString(parentType))
16801      t = parent;
16802    else {
16803      t = parent.predicate("fhir:"+parentType+'.'+name);
16804    }
16805    composeDomainResource(t, "PackagedProductDefinition", name, element, index);
16806    for (int i = 0; i < element.getIdentifier().size(); i++) {
16807      composeIdentifier(t, "PackagedProductDefinition", "identifier", element.getIdentifier().get(i), i);
16808    }
16809    if (element.hasNameElement()) {
16810      composeString(t, "PackagedProductDefinition", "name", element.getNameElement(), -1);
16811    }
16812    if (element.hasType()) {
16813      composeCodeableConcept(t, "PackagedProductDefinition", "type", element.getType(), -1);
16814    }
16815    for (int i = 0; i < element.getPackageFor().size(); i++) {
16816      composeReference(t, "PackagedProductDefinition", "packageFor", element.getPackageFor().get(i), i);
16817    }
16818    if (element.hasStatus()) {
16819      composeCodeableConcept(t, "PackagedProductDefinition", "status", element.getStatus(), -1);
16820    }
16821    if (element.hasStatusDateElement()) {
16822      composeDateTime(t, "PackagedProductDefinition", "statusDate", element.getStatusDateElement(), -1);
16823    }
16824    for (int i = 0; i < element.getContainedItemQuantity().size(); i++) {
16825      composeQuantity(t, "PackagedProductDefinition", "containedItemQuantity", element.getContainedItemQuantity().get(i), i);
16826    }
16827    if (element.hasDescriptionElement()) {
16828      composeMarkdown(t, "PackagedProductDefinition", "description", element.getDescriptionElement(), -1);
16829    }
16830    for (int i = 0; i < element.getLegalStatusOfSupply().size(); i++) {
16831      composePackagedProductDefinitionLegalStatusOfSupplyComponent(t, "PackagedProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply().get(i), i);
16832    }
16833    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
16834      composeMarketingStatus(t, "PackagedProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
16835    }
16836    for (int i = 0; i < element.getCharacteristic().size(); i++) {
16837      composeCodeableConcept(t, "PackagedProductDefinition", "characteristic", element.getCharacteristic().get(i), i);
16838    }
16839    if (element.hasCopackagedIndicatorElement()) {
16840      composeBoolean(t, "PackagedProductDefinition", "copackagedIndicator", element.getCopackagedIndicatorElement(), -1);
16841    }
16842    for (int i = 0; i < element.getManufacturer().size(); i++) {
16843      composeReference(t, "PackagedProductDefinition", "manufacturer", element.getManufacturer().get(i), i);
16844    }
16845    if (element.hasPackage()) {
16846      composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinition", "package", element.getPackage(), -1);
16847    }
16848  }
16849
16850  protected void composePackagedProductDefinitionLegalStatusOfSupplyComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionLegalStatusOfSupplyComponent element, int index) {
16851    if (element == null) 
16852      return;
16853    Complex t;
16854    if (Utilities.noString(parentType))
16855      t = parent;
16856    else {
16857      t = parent.predicate("fhir:"+parentType+'.'+name);
16858    }
16859    composeBackboneElement(t, "legalStatusOfSupply", name, element, index);
16860    if (element.hasCode()) {
16861      composeCodeableConcept(t, "PackagedProductDefinitionLegalStatusOfSupplyComponent", "code", element.getCode(), -1);
16862    }
16863    if (element.hasJurisdiction()) {
16864      composeCodeableConcept(t, "PackagedProductDefinitionLegalStatusOfSupplyComponent", "jurisdiction", element.getJurisdiction(), -1);
16865    }
16866  }
16867
16868  protected void composePackagedProductDefinitionPackageComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageComponent element, int index) {
16869    if (element == null) 
16870      return;
16871    Complex t;
16872    if (Utilities.noString(parentType))
16873      t = parent;
16874    else {
16875      t = parent.predicate("fhir:"+parentType+'.'+name);
16876    }
16877    composeBackboneElement(t, "package", name, element, index);
16878    for (int i = 0; i < element.getIdentifier().size(); i++) {
16879      composeIdentifier(t, "PackagedProductDefinitionPackageComponent", "identifier", element.getIdentifier().get(i), i);
16880    }
16881    if (element.hasType()) {
16882      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "type", element.getType(), -1);
16883    }
16884    if (element.hasQuantityElement()) {
16885      composeInteger(t, "PackagedProductDefinitionPackageComponent", "quantity", element.getQuantityElement(), -1);
16886    }
16887    for (int i = 0; i < element.getMaterial().size(); i++) {
16888      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "material", element.getMaterial().get(i), i);
16889    }
16890    for (int i = 0; i < element.getAlternateMaterial().size(); i++) {
16891      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "alternateMaterial", element.getAlternateMaterial().get(i), i);
16892    }
16893    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
16894      composeProductShelfLife(t, "PackagedProductDefinitionPackageComponent", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
16895    }
16896    for (int i = 0; i < element.getManufacturer().size(); i++) {
16897      composeReference(t, "PackagedProductDefinitionPackageComponent", "manufacturer", element.getManufacturer().get(i), i);
16898    }
16899    for (int i = 0; i < element.getProperty().size(); i++) {
16900      composePackagedProductDefinitionPackagePropertyComponent(t, "PackagedProductDefinitionPackageComponent", "property", element.getProperty().get(i), i);
16901    }
16902    for (int i = 0; i < element.getContainedItem().size(); i++) {
16903      composePackagedProductDefinitionPackageContainedItemComponent(t, "PackagedProductDefinitionPackageComponent", "containedItem", element.getContainedItem().get(i), i);
16904    }
16905    for (int i = 0; i < element.getPackage().size(); i++) {
16906      composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinitionPackageComponent", "package", element.getPackage().get(i), i);
16907    }
16908  }
16909
16910  protected void composePackagedProductDefinitionPackagePropertyComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackagePropertyComponent element, int index) {
16911    if (element == null) 
16912      return;
16913    Complex t;
16914    if (Utilities.noString(parentType))
16915      t = parent;
16916    else {
16917      t = parent.predicate("fhir:"+parentType+'.'+name);
16918    }
16919    composeBackboneElement(t, "property", name, element, index);
16920    if (element.hasType()) {
16921      composeCodeableConcept(t, "PackagedProductDefinitionPackagePropertyComponent", "type", element.getType(), -1);
16922    }
16923    if (element.hasValue()) {
16924      composeType(t, "PackagedProductDefinitionPackagePropertyComponent", "value", element.getValue(), -1);
16925    }
16926  }
16927
16928  protected void composePackagedProductDefinitionPackageContainedItemComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageContainedItemComponent element, int index) {
16929    if (element == null) 
16930      return;
16931    Complex t;
16932    if (Utilities.noString(parentType))
16933      t = parent;
16934    else {
16935      t = parent.predicate("fhir:"+parentType+'.'+name);
16936    }
16937    composeBackboneElement(t, "containedItem", name, element, index);
16938    if (element.hasItem()) {
16939      composeCodeableReference(t, "PackagedProductDefinitionPackageContainedItemComponent", "item", element.getItem(), -1);
16940    }
16941    if (element.hasAmount()) {
16942      composeQuantity(t, "PackagedProductDefinitionPackageContainedItemComponent", "amount", element.getAmount(), -1);
16943    }
16944  }
16945
16946  protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) {
16947    if (element == null) 
16948      return;
16949    Complex t;
16950    if (Utilities.noString(parentType))
16951      t = parent;
16952    else {
16953      t = parent.predicate("fhir:"+parentType+'.'+name);
16954    }
16955    composeResource(t, "Parameters", name, element, index);
16956    for (int i = 0; i < element.getParameter().size(); i++) {
16957      composeParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i);
16958    }
16959  }
16960
16961  protected void composeParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) {
16962    if (element == null) 
16963      return;
16964    Complex t;
16965    if (Utilities.noString(parentType))
16966      t = parent;
16967    else {
16968      t = parent.predicate("fhir:"+parentType+'.'+name);
16969    }
16970    composeBackboneElement(t, "parameter", name, element, index);
16971    if (element.hasNameElement()) {
16972      composeString(t, "ParametersParameterComponent", "name", element.getNameElement(), -1);
16973    }
16974    if (element.hasValue()) {
16975      composeType(t, "ParametersParameterComponent", "value", element.getValue(), -1);
16976    }
16977    if (element.hasResource()) {
16978      composeResource(t, "ParametersParameterComponent", "resource", element.getResource(), -1);
16979    }
16980    for (int i = 0; i < element.getPart().size(); i++) {
16981      composeParametersParameterComponent(t, "ParametersParameterComponent", "part", element.getPart().get(i), i);
16982    }
16983  }
16984
16985  protected void composePatient(Complex parent, String parentType, String name, Patient element, int index) {
16986    if (element == null) 
16987      return;
16988    Complex t;
16989    if (Utilities.noString(parentType))
16990      t = parent;
16991    else {
16992      t = parent.predicate("fhir:"+parentType+'.'+name);
16993    }
16994    composeDomainResource(t, "Patient", name, element, index);
16995    for (int i = 0; i < element.getIdentifier().size(); i++) {
16996      composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i);
16997    }
16998    if (element.hasActiveElement()) {
16999      composeBoolean(t, "Patient", "active", element.getActiveElement(), -1);
17000    }
17001    for (int i = 0; i < element.getName().size(); i++) {
17002      composeHumanName(t, "Patient", "name", element.getName().get(i), i);
17003    }
17004    for (int i = 0; i < element.getTelecom().size(); i++) {
17005      composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i);
17006    }
17007    if (element.hasGenderElement()) {
17008      composeEnum(t, "Patient", "gender", element.getGenderElement(), -1);
17009    }
17010    if (element.hasBirthDateElement()) {
17011      composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1);
17012    }
17013    if (element.hasDeceased()) {
17014      composeType(t, "Patient", "deceased", element.getDeceased(), -1);
17015    }
17016    for (int i = 0; i < element.getAddress().size(); i++) {
17017      composeAddress(t, "Patient", "address", element.getAddress().get(i), i);
17018    }
17019    if (element.hasMaritalStatus()) {
17020      composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1);
17021    }
17022    if (element.hasMultipleBirth()) {
17023      composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1);
17024    }
17025    for (int i = 0; i < element.getPhoto().size(); i++) {
17026      composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i);
17027    }
17028    for (int i = 0; i < element.getContact().size(); i++) {
17029      composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i);
17030    }
17031    for (int i = 0; i < element.getCommunication().size(); i++) {
17032      composePatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i);
17033    }
17034    for (int i = 0; i < element.getGeneralPractitioner().size(); i++) {
17035      composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i);
17036    }
17037    if (element.hasManagingOrganization()) {
17038      composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1);
17039    }
17040    for (int i = 0; i < element.getLink().size(); i++) {
17041      composePatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i);
17042    }
17043  }
17044
17045  protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) {
17046    if (element == null) 
17047      return;
17048    Complex t;
17049    if (Utilities.noString(parentType))
17050      t = parent;
17051    else {
17052      t = parent.predicate("fhir:"+parentType+'.'+name);
17053    }
17054    composeBackboneElement(t, "contact", name, element, index);
17055    for (int i = 0; i < element.getRelationship().size(); i++) {
17056      composeCodeableConcept(t, "ContactComponent", "relationship", element.getRelationship().get(i), i);
17057    }
17058    if (element.hasName()) {
17059      composeHumanName(t, "ContactComponent", "name", element.getName(), -1);
17060    }
17061    for (int i = 0; i < element.getTelecom().size(); i++) {
17062      composeContactPoint(t, "ContactComponent", "telecom", element.getTelecom().get(i), i);
17063    }
17064    if (element.hasAddress()) {
17065      composeAddress(t, "ContactComponent", "address", element.getAddress(), -1);
17066    }
17067    if (element.hasGenderElement()) {
17068      composeEnum(t, "ContactComponent", "gender", element.getGenderElement(), -1);
17069    }
17070    if (element.hasOrganization()) {
17071      composeReference(t, "ContactComponent", "organization", element.getOrganization(), -1);
17072    }
17073    if (element.hasPeriod()) {
17074      composePeriod(t, "ContactComponent", "period", element.getPeriod(), -1);
17075    }
17076  }
17077
17078  protected void composePatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) {
17079    if (element == null) 
17080      return;
17081    Complex t;
17082    if (Utilities.noString(parentType))
17083      t = parent;
17084    else {
17085      t = parent.predicate("fhir:"+parentType+'.'+name);
17086    }
17087    composeBackboneElement(t, "communication", name, element, index);
17088    if (element.hasLanguage()) {
17089      composeCodeableConcept(t, "PatientCommunicationComponent", "language", element.getLanguage(), -1);
17090    }
17091    if (element.hasPreferredElement()) {
17092      composeBoolean(t, "PatientCommunicationComponent", "preferred", element.getPreferredElement(), -1);
17093    }
17094  }
17095
17096  protected void composePatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) {
17097    if (element == null) 
17098      return;
17099    Complex t;
17100    if (Utilities.noString(parentType))
17101      t = parent;
17102    else {
17103      t = parent.predicate("fhir:"+parentType+'.'+name);
17104    }
17105    composeBackboneElement(t, "link", name, element, index);
17106    if (element.hasOther()) {
17107      composeReference(t, "PatientLinkComponent", "other", element.getOther(), -1);
17108    }
17109    if (element.hasTypeElement()) {
17110      composeEnum(t, "PatientLinkComponent", "type", element.getTypeElement(), -1);
17111    }
17112  }
17113
17114  protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) {
17115    if (element == null) 
17116      return;
17117    Complex t;
17118    if (Utilities.noString(parentType))
17119      t = parent;
17120    else {
17121      t = parent.predicate("fhir:"+parentType+'.'+name);
17122    }
17123    composeDomainResource(t, "PaymentNotice", name, element, index);
17124    for (int i = 0; i < element.getIdentifier().size(); i++) {
17125      composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i);
17126    }
17127    if (element.hasStatusElement()) {
17128      composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1);
17129    }
17130    if (element.hasRequest()) {
17131      composeReference(t, "PaymentNotice", "request", element.getRequest(), -1);
17132    }
17133    if (element.hasResponse()) {
17134      composeReference(t, "PaymentNotice", "response", element.getResponse(), -1);
17135    }
17136    if (element.hasCreatedElement()) {
17137      composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1);
17138    }
17139    if (element.hasProvider()) {
17140      composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1);
17141    }
17142    if (element.hasPayment()) {
17143      composeReference(t, "PaymentNotice", "payment", element.getPayment(), -1);
17144    }
17145    if (element.hasPaymentDateElement()) {
17146      composeDate(t, "PaymentNotice", "paymentDate", element.getPaymentDateElement(), -1);
17147    }
17148    if (element.hasPayee()) {
17149      composeReference(t, "PaymentNotice", "payee", element.getPayee(), -1);
17150    }
17151    if (element.hasRecipient()) {
17152      composeReference(t, "PaymentNotice", "recipient", element.getRecipient(), -1);
17153    }
17154    if (element.hasAmount()) {
17155      composeMoney(t, "PaymentNotice", "amount", element.getAmount(), -1);
17156    }
17157    if (element.hasPaymentStatus()) {
17158      composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1);
17159    }
17160  }
17161
17162  protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) {
17163    if (element == null) 
17164      return;
17165    Complex t;
17166    if (Utilities.noString(parentType))
17167      t = parent;
17168    else {
17169      t = parent.predicate("fhir:"+parentType+'.'+name);
17170    }
17171    composeDomainResource(t, "PaymentReconciliation", name, element, index);
17172    for (int i = 0; i < element.getIdentifier().size(); i++) {
17173      composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i);
17174    }
17175    if (element.hasStatusElement()) {
17176      composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1);
17177    }
17178    if (element.hasPeriod()) {
17179      composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1);
17180    }
17181    if (element.hasCreatedElement()) {
17182      composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1);
17183    }
17184    if (element.hasPaymentIssuer()) {
17185      composeReference(t, "PaymentReconciliation", "paymentIssuer", element.getPaymentIssuer(), -1);
17186    }
17187    if (element.hasRequest()) {
17188      composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1);
17189    }
17190    if (element.hasRequestor()) {
17191      composeReference(t, "PaymentReconciliation", "requestor", element.getRequestor(), -1);
17192    }
17193    if (element.hasOutcomeElement()) {
17194      composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1);
17195    }
17196    if (element.hasDispositionElement()) {
17197      composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1);
17198    }
17199    if (element.hasPaymentDateElement()) {
17200      composeDate(t, "PaymentReconciliation", "paymentDate", element.getPaymentDateElement(), -1);
17201    }
17202    if (element.hasPaymentAmount()) {
17203      composeMoney(t, "PaymentReconciliation", "paymentAmount", element.getPaymentAmount(), -1);
17204    }
17205    if (element.hasPaymentIdentifier()) {
17206      composeIdentifier(t, "PaymentReconciliation", "paymentIdentifier", element.getPaymentIdentifier(), -1);
17207    }
17208    for (int i = 0; i < element.getDetail().size(); i++) {
17209      composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i);
17210    }
17211    if (element.hasFormCode()) {
17212      composeCodeableConcept(t, "PaymentReconciliation", "formCode", element.getFormCode(), -1);
17213    }
17214    for (int i = 0; i < element.getProcessNote().size(); i++) {
17215      composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i);
17216    }
17217  }
17218
17219  protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) {
17220    if (element == null) 
17221      return;
17222    Complex t;
17223    if (Utilities.noString(parentType))
17224      t = parent;
17225    else {
17226      t = parent.predicate("fhir:"+parentType+'.'+name);
17227    }
17228    composeBackboneElement(t, "detail", name, element, index);
17229    if (element.hasIdentifier()) {
17230      composeIdentifier(t, "DetailsComponent", "identifier", element.getIdentifier(), -1);
17231    }
17232    if (element.hasPredecessor()) {
17233      composeIdentifier(t, "DetailsComponent", "predecessor", element.getPredecessor(), -1);
17234    }
17235    if (element.hasType()) {
17236      composeCodeableConcept(t, "DetailsComponent", "type", element.getType(), -1);
17237    }
17238    if (element.hasRequest()) {
17239      composeReference(t, "DetailsComponent", "request", element.getRequest(), -1);
17240    }
17241    if (element.hasSubmitter()) {
17242      composeReference(t, "DetailsComponent", "submitter", element.getSubmitter(), -1);
17243    }
17244    if (element.hasResponse()) {
17245      composeReference(t, "DetailsComponent", "response", element.getResponse(), -1);
17246    }
17247    if (element.hasDateElement()) {
17248      composeDate(t, "DetailsComponent", "date", element.getDateElement(), -1);
17249    }
17250    if (element.hasResponsible()) {
17251      composeReference(t, "DetailsComponent", "responsible", element.getResponsible(), -1);
17252    }
17253    if (element.hasPayee()) {
17254      composeReference(t, "DetailsComponent", "payee", element.getPayee(), -1);
17255    }
17256    if (element.hasAmount()) {
17257      composeMoney(t, "DetailsComponent", "amount", element.getAmount(), -1);
17258    }
17259  }
17260
17261  protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) {
17262    if (element == null) 
17263      return;
17264    Complex t;
17265    if (Utilities.noString(parentType))
17266      t = parent;
17267    else {
17268      t = parent.predicate("fhir:"+parentType+'.'+name);
17269    }
17270    composeBackboneElement(t, "processNote", name, element, index);
17271    if (element.hasTypeElement()) {
17272      composeEnum(t, "NotesComponent", "type", element.getTypeElement(), -1);
17273    }
17274    if (element.hasTextElement()) {
17275      composeString(t, "NotesComponent", "text", element.getTextElement(), -1);
17276    }
17277  }
17278
17279  protected void composePerson(Complex parent, String parentType, String name, Person element, int index) {
17280    if (element == null) 
17281      return;
17282    Complex t;
17283    if (Utilities.noString(parentType))
17284      t = parent;
17285    else {
17286      t = parent.predicate("fhir:"+parentType+'.'+name);
17287    }
17288    composeDomainResource(t, "Person", name, element, index);
17289    for (int i = 0; i < element.getIdentifier().size(); i++) {
17290      composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i);
17291    }
17292    for (int i = 0; i < element.getName().size(); i++) {
17293      composeHumanName(t, "Person", "name", element.getName().get(i), i);
17294    }
17295    for (int i = 0; i < element.getTelecom().size(); i++) {
17296      composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i);
17297    }
17298    if (element.hasGenderElement()) {
17299      composeEnum(t, "Person", "gender", element.getGenderElement(), -1);
17300    }
17301    if (element.hasBirthDateElement()) {
17302      composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1);
17303    }
17304    for (int i = 0; i < element.getAddress().size(); i++) {
17305      composeAddress(t, "Person", "address", element.getAddress().get(i), i);
17306    }
17307    if (element.hasPhoto()) {
17308      composeAttachment(t, "Person", "photo", element.getPhoto(), -1);
17309    }
17310    if (element.hasManagingOrganization()) {
17311      composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1);
17312    }
17313    if (element.hasActiveElement()) {
17314      composeBoolean(t, "Person", "active", element.getActiveElement(), -1);
17315    }
17316    for (int i = 0; i < element.getLink().size(); i++) {
17317      composePersonLinkComponent(t, "Person", "link", element.getLink().get(i), i);
17318    }
17319  }
17320
17321  protected void composePersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) {
17322    if (element == null) 
17323      return;
17324    Complex t;
17325    if (Utilities.noString(parentType))
17326      t = parent;
17327    else {
17328      t = parent.predicate("fhir:"+parentType+'.'+name);
17329    }
17330    composeBackboneElement(t, "link", name, element, index);
17331    if (element.hasTarget()) {
17332      composeReference(t, "PersonLinkComponent", "target", element.getTarget(), -1);
17333    }
17334    if (element.hasAssuranceElement()) {
17335      composeEnum(t, "PersonLinkComponent", "assurance", element.getAssuranceElement(), -1);
17336    }
17337  }
17338
17339  protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition element, int index) {
17340    if (element == null) 
17341      return;
17342    Complex t;
17343    if (Utilities.noString(parentType))
17344      t = parent;
17345    else {
17346      t = parent.predicate("fhir:"+parentType+'.'+name);
17347    }
17348    composeDomainResource(t, "PlanDefinition", name, element, index);
17349    if (element.hasUrlElement()) {
17350      composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1);
17351    }
17352    for (int i = 0; i < element.getIdentifier().size(); i++) {
17353      composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i);
17354    }
17355    if (element.hasVersionElement()) {
17356      composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1);
17357    }
17358    if (element.hasNameElement()) {
17359      composeString(t, "PlanDefinition", "name", element.getNameElement(), -1);
17360    }
17361    if (element.hasTitleElement()) {
17362      composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1);
17363    }
17364    if (element.hasSubtitleElement()) {
17365      composeString(t, "PlanDefinition", "subtitle", element.getSubtitleElement(), -1);
17366    }
17367    if (element.hasType()) {
17368      composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1);
17369    }
17370    if (element.hasStatusElement()) {
17371      composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1);
17372    }
17373    if (element.hasExperimentalElement()) {
17374      composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1);
17375    }
17376    if (element.hasSubject()) {
17377      composeType(t, "PlanDefinition", "subject", element.getSubject(), -1);
17378    }
17379    if (element.hasDateElement()) {
17380      composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1);
17381    }
17382    if (element.hasPublisherElement()) {
17383      composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1);
17384    }
17385    for (int i = 0; i < element.getContact().size(); i++) {
17386      composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i);
17387    }
17388    if (element.hasDescriptionElement()) {
17389      composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1);
17390    }
17391    for (int i = 0; i < element.getUseContext().size(); i++) {
17392      composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i);
17393    }
17394    for (int i = 0; i < element.getJurisdiction().size(); i++) {
17395      composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
17396    }
17397    if (element.hasPurposeElement()) {
17398      composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1);
17399    }
17400    if (element.hasUsageElement()) {
17401      composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1);
17402    }
17403    if (element.hasCopyrightElement()) {
17404      composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1);
17405    }
17406    if (element.hasApprovalDateElement()) {
17407      composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1);
17408    }
17409    if (element.hasLastReviewDateElement()) {
17410      composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
17411    }
17412    if (element.hasEffectivePeriod()) {
17413      composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
17414    }
17415    for (int i = 0; i < element.getTopic().size(); i++) {
17416      composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i);
17417    }
17418    for (int i = 0; i < element.getAuthor().size(); i++) {
17419      composeContactDetail(t, "PlanDefinition", "author", element.getAuthor().get(i), i);
17420    }
17421    for (int i = 0; i < element.getEditor().size(); i++) {
17422      composeContactDetail(t, "PlanDefinition", "editor", element.getEditor().get(i), i);
17423    }
17424    for (int i = 0; i < element.getReviewer().size(); i++) {
17425      composeContactDetail(t, "PlanDefinition", "reviewer", element.getReviewer().get(i), i);
17426    }
17427    for (int i = 0; i < element.getEndorser().size(); i++) {
17428      composeContactDetail(t, "PlanDefinition", "endorser", element.getEndorser().get(i), i);
17429    }
17430    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
17431      composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
17432    }
17433    for (int i = 0; i < element.getLibrary().size(); i++) {
17434      composeCanonical(t, "PlanDefinition", "library", element.getLibrary().get(i), i);
17435    }
17436    for (int i = 0; i < element.getGoal().size(); i++) {
17437      composePlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i);
17438    }
17439    for (int i = 0; i < element.getAction().size(); i++) {
17440      composePlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i);
17441    }
17442  }
17443
17444  protected void composePlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) {
17445    if (element == null) 
17446      return;
17447    Complex t;
17448    if (Utilities.noString(parentType))
17449      t = parent;
17450    else {
17451      t = parent.predicate("fhir:"+parentType+'.'+name);
17452    }
17453    composeBackboneElement(t, "goal", name, element, index);
17454    if (element.hasCategory()) {
17455      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "category", element.getCategory(), -1);
17456    }
17457    if (element.hasDescription()) {
17458      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "description", element.getDescription(), -1);
17459    }
17460    if (element.hasPriority()) {
17461      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "priority", element.getPriority(), -1);
17462    }
17463    if (element.hasStart()) {
17464      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "start", element.getStart(), -1);
17465    }
17466    for (int i = 0; i < element.getAddresses().size(); i++) {
17467      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "addresses", element.getAddresses().get(i), i);
17468    }
17469    for (int i = 0; i < element.getDocumentation().size(); i++) {
17470      composeRelatedArtifact(t, "PlanDefinitionGoalComponent", "documentation", element.getDocumentation().get(i), i);
17471    }
17472    for (int i = 0; i < element.getTarget().size(); i++) {
17473      composePlanDefinitionGoalTargetComponent(t, "PlanDefinitionGoalComponent", "target", element.getTarget().get(i), i);
17474    }
17475  }
17476
17477  protected void composePlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) {
17478    if (element == null) 
17479      return;
17480    Complex t;
17481    if (Utilities.noString(parentType))
17482      t = parent;
17483    else {
17484      t = parent.predicate("fhir:"+parentType+'.'+name);
17485    }
17486    composeBackboneElement(t, "target", name, element, index);
17487    if (element.hasMeasure()) {
17488      composeCodeableConcept(t, "PlanDefinitionGoalTargetComponent", "measure", element.getMeasure(), -1);
17489    }
17490    if (element.hasDetail()) {
17491      composeType(t, "PlanDefinitionGoalTargetComponent", "detail", element.getDetail(), -1);
17492    }
17493    if (element.hasDue()) {
17494      composeDuration(t, "PlanDefinitionGoalTargetComponent", "due", element.getDue(), -1);
17495    }
17496  }
17497
17498  protected void composePlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent element, int index) {
17499    if (element == null) 
17500      return;
17501    Complex t;
17502    if (Utilities.noString(parentType))
17503      t = parent;
17504    else {
17505      t = parent.predicate("fhir:"+parentType+'.'+name);
17506    }
17507    composeBackboneElement(t, "action", name, element, index);
17508    if (element.hasPrefixElement()) {
17509      composeString(t, "PlanDefinitionActionComponent", "prefix", element.getPrefixElement(), -1);
17510    }
17511    if (element.hasTitleElement()) {
17512      composeString(t, "PlanDefinitionActionComponent", "title", element.getTitleElement(), -1);
17513    }
17514    if (element.hasDescriptionElement()) {
17515      composeString(t, "PlanDefinitionActionComponent", "description", element.getDescriptionElement(), -1);
17516    }
17517    if (element.hasTextEquivalentElement()) {
17518      composeString(t, "PlanDefinitionActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
17519    }
17520    if (element.hasPriorityElement()) {
17521      composeEnum(t, "PlanDefinitionActionComponent", "priority", element.getPriorityElement(), -1);
17522    }
17523    for (int i = 0; i < element.getCode().size(); i++) {
17524      composeCodeableConcept(t, "PlanDefinitionActionComponent", "code", element.getCode().get(i), i);
17525    }
17526    for (int i = 0; i < element.getReason().size(); i++) {
17527      composeCodeableConcept(t, "PlanDefinitionActionComponent", "reason", element.getReason().get(i), i);
17528    }
17529    for (int i = 0; i < element.getDocumentation().size(); i++) {
17530      composeRelatedArtifact(t, "PlanDefinitionActionComponent", "documentation", element.getDocumentation().get(i), i);
17531    }
17532    for (int i = 0; i < element.getGoalId().size(); i++) {
17533      composeId(t, "PlanDefinitionActionComponent", "goalId", element.getGoalId().get(i), i);
17534    }
17535    if (element.hasSubject()) {
17536      composeType(t, "PlanDefinitionActionComponent", "subject", element.getSubject(), -1);
17537    }
17538    for (int i = 0; i < element.getTrigger().size(); i++) {
17539      composeTriggerDefinition(t, "PlanDefinitionActionComponent", "trigger", element.getTrigger().get(i), i);
17540    }
17541    for (int i = 0; i < element.getCondition().size(); i++) {
17542      composePlanDefinitionActionConditionComponent(t, "PlanDefinitionActionComponent", "condition", element.getCondition().get(i), i);
17543    }
17544    for (int i = 0; i < element.getInput().size(); i++) {
17545      composeDataRequirement(t, "PlanDefinitionActionComponent", "input", element.getInput().get(i), i);
17546    }
17547    for (int i = 0; i < element.getOutput().size(); i++) {
17548      composeDataRequirement(t, "PlanDefinitionActionComponent", "output", element.getOutput().get(i), i);
17549    }
17550    for (int i = 0; i < element.getRelatedAction().size(); i++) {
17551      composePlanDefinitionActionRelatedActionComponent(t, "PlanDefinitionActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
17552    }
17553    if (element.hasTiming()) {
17554      composeType(t, "PlanDefinitionActionComponent", "timing", element.getTiming(), -1);
17555    }
17556    for (int i = 0; i < element.getParticipant().size(); i++) {
17557      composePlanDefinitionActionParticipantComponent(t, "PlanDefinitionActionComponent", "participant", element.getParticipant().get(i), i);
17558    }
17559    if (element.hasType()) {
17560      composeCodeableConcept(t, "PlanDefinitionActionComponent", "type", element.getType(), -1);
17561    }
17562    if (element.hasGroupingBehaviorElement()) {
17563      composeEnum(t, "PlanDefinitionActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
17564    }
17565    if (element.hasSelectionBehaviorElement()) {
17566      composeEnum(t, "PlanDefinitionActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
17567    }
17568    if (element.hasRequiredBehaviorElement()) {
17569      composeEnum(t, "PlanDefinitionActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
17570    }
17571    if (element.hasPrecheckBehaviorElement()) {
17572      composeEnum(t, "PlanDefinitionActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
17573    }
17574    if (element.hasCardinalityBehaviorElement()) {
17575      composeEnum(t, "PlanDefinitionActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
17576    }
17577    if (element.hasDefinition()) {
17578      composeType(t, "PlanDefinitionActionComponent", "definition", element.getDefinition(), -1);
17579    }
17580    if (element.hasTransformElement()) {
17581      composeCanonical(t, "PlanDefinitionActionComponent", "transform", element.getTransformElement(), -1);
17582    }
17583    for (int i = 0; i < element.getDynamicValue().size(); i++) {
17584      composePlanDefinitionActionDynamicValueComponent(t, "PlanDefinitionActionComponent", "dynamicValue", element.getDynamicValue().get(i), i);
17585    }
17586    for (int i = 0; i < element.getAction().size(); i++) {
17587      composePlanDefinitionActionComponent(t, "PlanDefinitionActionComponent", "action", element.getAction().get(i), i);
17588    }
17589  }
17590
17591  protected void composePlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) {
17592    if (element == null) 
17593      return;
17594    Complex t;
17595    if (Utilities.noString(parentType))
17596      t = parent;
17597    else {
17598      t = parent.predicate("fhir:"+parentType+'.'+name);
17599    }
17600    composeBackboneElement(t, "condition", name, element, index);
17601    if (element.hasKindElement()) {
17602      composeEnum(t, "PlanDefinitionActionConditionComponent", "kind", element.getKindElement(), -1);
17603    }
17604    if (element.hasExpression()) {
17605      composeExpression(t, "PlanDefinitionActionConditionComponent", "expression", element.getExpression(), -1);
17606    }
17607  }
17608
17609  protected void composePlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent element, int index) {
17610    if (element == null) 
17611      return;
17612    Complex t;
17613    if (Utilities.noString(parentType))
17614      t = parent;
17615    else {
17616      t = parent.predicate("fhir:"+parentType+'.'+name);
17617    }
17618    composeBackboneElement(t, "relatedAction", name, element, index);
17619    if (element.hasActionIdElement()) {
17620      composeId(t, "PlanDefinitionActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1);
17621    }
17622    if (element.hasRelationshipElement()) {
17623      composeEnum(t, "PlanDefinitionActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
17624    }
17625    if (element.hasOffset()) {
17626      composeType(t, "PlanDefinitionActionRelatedActionComponent", "offset", element.getOffset(), -1);
17627    }
17628  }
17629
17630  protected void composePlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) {
17631    if (element == null) 
17632      return;
17633    Complex t;
17634    if (Utilities.noString(parentType))
17635      t = parent;
17636    else {
17637      t = parent.predicate("fhir:"+parentType+'.'+name);
17638    }
17639    composeBackboneElement(t, "participant", name, element, index);
17640    if (element.hasTypeElement()) {
17641      composeEnum(t, "PlanDefinitionActionParticipantComponent", "type", element.getTypeElement(), -1);
17642    }
17643    if (element.hasRole()) {
17644      composeCodeableConcept(t, "PlanDefinitionActionParticipantComponent", "role", element.getRole(), -1);
17645    }
17646  }
17647
17648  protected void composePlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) {
17649    if (element == null) 
17650      return;
17651    Complex t;
17652    if (Utilities.noString(parentType))
17653      t = parent;
17654    else {
17655      t = parent.predicate("fhir:"+parentType+'.'+name);
17656    }
17657    composeBackboneElement(t, "dynamicValue", name, element, index);
17658    if (element.hasPathElement()) {
17659      composeString(t, "PlanDefinitionActionDynamicValueComponent", "path", element.getPathElement(), -1);
17660    }
17661    if (element.hasExpression()) {
17662      composeExpression(t, "PlanDefinitionActionDynamicValueComponent", "expression", element.getExpression(), -1);
17663    }
17664  }
17665
17666  protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) {
17667    if (element == null) 
17668      return;
17669    Complex t;
17670    if (Utilities.noString(parentType))
17671      t = parent;
17672    else {
17673      t = parent.predicate("fhir:"+parentType+'.'+name);
17674    }
17675    composeDomainResource(t, "Practitioner", name, element, index);
17676    for (int i = 0; i < element.getIdentifier().size(); i++) {
17677      composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i);
17678    }
17679    if (element.hasActiveElement()) {
17680      composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1);
17681    }
17682    for (int i = 0; i < element.getName().size(); i++) {
17683      composeHumanName(t, "Practitioner", "name", element.getName().get(i), i);
17684    }
17685    for (int i = 0; i < element.getTelecom().size(); i++) {
17686      composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i);
17687    }
17688    for (int i = 0; i < element.getAddress().size(); i++) {
17689      composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i);
17690    }
17691    if (element.hasGenderElement()) {
17692      composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1);
17693    }
17694    if (element.hasBirthDateElement()) {
17695      composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1);
17696    }
17697    for (int i = 0; i < element.getPhoto().size(); i++) {
17698      composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i);
17699    }
17700    for (int i = 0; i < element.getQualification().size(); i++) {
17701      composePractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i);
17702    }
17703    for (int i = 0; i < element.getCommunication().size(); i++) {
17704      composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i);
17705    }
17706  }
17707
17708  protected void composePractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) {
17709    if (element == null) 
17710      return;
17711    Complex t;
17712    if (Utilities.noString(parentType))
17713      t = parent;
17714    else {
17715      t = parent.predicate("fhir:"+parentType+'.'+name);
17716    }
17717    composeBackboneElement(t, "qualification", name, element, index);
17718    for (int i = 0; i < element.getIdentifier().size(); i++) {
17719      composeIdentifier(t, "PractitionerQualificationComponent", "identifier", element.getIdentifier().get(i), i);
17720    }
17721    if (element.hasCode()) {
17722      composeCodeableConcept(t, "PractitionerQualificationComponent", "code", element.getCode(), -1);
17723    }
17724    if (element.hasPeriod()) {
17725      composePeriod(t, "PractitionerQualificationComponent", "period", element.getPeriod(), -1);
17726    }
17727    if (element.hasIssuer()) {
17728      composeReference(t, "PractitionerQualificationComponent", "issuer", element.getIssuer(), -1);
17729    }
17730  }
17731
17732  protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) {
17733    if (element == null) 
17734      return;
17735    Complex t;
17736    if (Utilities.noString(parentType))
17737      t = parent;
17738    else {
17739      t = parent.predicate("fhir:"+parentType+'.'+name);
17740    }
17741    composeDomainResource(t, "PractitionerRole", name, element, index);
17742    for (int i = 0; i < element.getIdentifier().size(); i++) {
17743      composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i);
17744    }
17745    if (element.hasActiveElement()) {
17746      composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1);
17747    }
17748    if (element.hasPeriod()) {
17749      composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1);
17750    }
17751    if (element.hasPractitioner()) {
17752      composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1);
17753    }
17754    if (element.hasOrganization()) {
17755      composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1);
17756    }
17757    for (int i = 0; i < element.getCode().size(); i++) {
17758      composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i);
17759    }
17760    for (int i = 0; i < element.getSpecialty().size(); i++) {
17761      composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i);
17762    }
17763    for (int i = 0; i < element.getLocation().size(); i++) {
17764      composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i);
17765    }
17766    for (int i = 0; i < element.getHealthcareService().size(); i++) {
17767      composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i);
17768    }
17769    for (int i = 0; i < element.getTelecom().size(); i++) {
17770      composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i);
17771    }
17772    for (int i = 0; i < element.getAvailableTime().size(); i++) {
17773      composePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i);
17774    }
17775    for (int i = 0; i < element.getNotAvailable().size(); i++) {
17776      composePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i);
17777    }
17778    if (element.hasAvailabilityExceptionsElement()) {
17779      composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
17780    }
17781    for (int i = 0; i < element.getEndpoint().size(); i++) {
17782      composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i);
17783    }
17784  }
17785
17786  protected void composePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) {
17787    if (element == null) 
17788      return;
17789    Complex t;
17790    if (Utilities.noString(parentType))
17791      t = parent;
17792    else {
17793      t = parent.predicate("fhir:"+parentType+'.'+name);
17794    }
17795    composeBackboneElement(t, "availableTime", name, element, index);
17796    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
17797      composeEnum(t, "PractitionerRoleAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
17798    }
17799    if (element.hasAllDayElement()) {
17800      composeBoolean(t, "PractitionerRoleAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
17801    }
17802    if (element.hasAvailableStartTimeElement()) {
17803      composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
17804    }
17805    if (element.hasAvailableEndTimeElement()) {
17806      composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
17807    }
17808  }
17809
17810  protected void composePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) {
17811    if (element == null) 
17812      return;
17813    Complex t;
17814    if (Utilities.noString(parentType))
17815      t = parent;
17816    else {
17817      t = parent.predicate("fhir:"+parentType+'.'+name);
17818    }
17819    composeBackboneElement(t, "notAvailable", name, element, index);
17820    if (element.hasDescriptionElement()) {
17821      composeString(t, "PractitionerRoleNotAvailableComponent", "description", element.getDescriptionElement(), -1);
17822    }
17823    if (element.hasDuring()) {
17824      composePeriod(t, "PractitionerRoleNotAvailableComponent", "during", element.getDuring(), -1);
17825    }
17826  }
17827
17828  protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) {
17829    if (element == null) 
17830      return;
17831    Complex t;
17832    if (Utilities.noString(parentType))
17833      t = parent;
17834    else {
17835      t = parent.predicate("fhir:"+parentType+'.'+name);
17836    }
17837    composeDomainResource(t, "Procedure", name, element, index);
17838    for (int i = 0; i < element.getIdentifier().size(); i++) {
17839      composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i);
17840    }
17841    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
17842      composeCanonical(t, "Procedure", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
17843    }
17844    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
17845      composeUri(t, "Procedure", "instantiatesUri", element.getInstantiatesUri().get(i), i);
17846    }
17847    for (int i = 0; i < element.getBasedOn().size(); i++) {
17848      composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i);
17849    }
17850    for (int i = 0; i < element.getPartOf().size(); i++) {
17851      composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i);
17852    }
17853    if (element.hasStatusElement()) {
17854      composeEnum(t, "Procedure", "status", element.getStatusElement(), -1);
17855    }
17856    if (element.hasStatusReason()) {
17857      composeCodeableConcept(t, "Procedure", "statusReason", element.getStatusReason(), -1);
17858    }
17859    if (element.hasCategory()) {
17860      composeCodeableConcept(t, "Procedure", "category", element.getCategory(), -1);
17861    }
17862    if (element.hasCode()) {
17863      composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1);
17864    }
17865    if (element.hasSubject()) {
17866      composeReference(t, "Procedure", "subject", element.getSubject(), -1);
17867    }
17868    if (element.hasEncounter()) {
17869      composeReference(t, "Procedure", "encounter", element.getEncounter(), -1);
17870    }
17871    if (element.hasPerformed()) {
17872      composeType(t, "Procedure", "performed", element.getPerformed(), -1);
17873    }
17874    if (element.hasRecorder()) {
17875      composeReference(t, "Procedure", "recorder", element.getRecorder(), -1);
17876    }
17877    if (element.hasAsserter()) {
17878      composeReference(t, "Procedure", "asserter", element.getAsserter(), -1);
17879    }
17880    for (int i = 0; i < element.getPerformer().size(); i++) {
17881      composeProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i);
17882    }
17883    if (element.hasLocation()) {
17884      composeReference(t, "Procedure", "location", element.getLocation(), -1);
17885    }
17886    for (int i = 0; i < element.getReasonCode().size(); i++) {
17887      composeCodeableConcept(t, "Procedure", "reasonCode", element.getReasonCode().get(i), i);
17888    }
17889    for (int i = 0; i < element.getReasonReference().size(); i++) {
17890      composeReference(t, "Procedure", "reasonReference", element.getReasonReference().get(i), i);
17891    }
17892    for (int i = 0; i < element.getBodySite().size(); i++) {
17893      composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i);
17894    }
17895    if (element.hasOutcome()) {
17896      composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1);
17897    }
17898    for (int i = 0; i < element.getReport().size(); i++) {
17899      composeReference(t, "Procedure", "report", element.getReport().get(i), i);
17900    }
17901    for (int i = 0; i < element.getComplication().size(); i++) {
17902      composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i);
17903    }
17904    for (int i = 0; i < element.getComplicationDetail().size(); i++) {
17905      composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i);
17906    }
17907    for (int i = 0; i < element.getFollowUp().size(); i++) {
17908      composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i);
17909    }
17910    for (int i = 0; i < element.getNote().size(); i++) {
17911      composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i);
17912    }
17913    for (int i = 0; i < element.getFocalDevice().size(); i++) {
17914      composeProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i);
17915    }
17916    for (int i = 0; i < element.getUsedReference().size(); i++) {
17917      composeReference(t, "Procedure", "usedReference", element.getUsedReference().get(i), i);
17918    }
17919    for (int i = 0; i < element.getUsedCode().size(); i++) {
17920      composeCodeableConcept(t, "Procedure", "usedCode", element.getUsedCode().get(i), i);
17921    }
17922  }
17923
17924  protected void composeProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) {
17925    if (element == null) 
17926      return;
17927    Complex t;
17928    if (Utilities.noString(parentType))
17929      t = parent;
17930    else {
17931      t = parent.predicate("fhir:"+parentType+'.'+name);
17932    }
17933    composeBackboneElement(t, "performer", name, element, index);
17934    if (element.hasFunction()) {
17935      composeCodeableConcept(t, "ProcedurePerformerComponent", "function", element.getFunction(), -1);
17936    }
17937    if (element.hasActor()) {
17938      composeReference(t, "ProcedurePerformerComponent", "actor", element.getActor(), -1);
17939    }
17940    if (element.hasOnBehalfOf()) {
17941      composeReference(t, "ProcedurePerformerComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
17942    }
17943  }
17944
17945  protected void composeProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) {
17946    if (element == null) 
17947      return;
17948    Complex t;
17949    if (Utilities.noString(parentType))
17950      t = parent;
17951    else {
17952      t = parent.predicate("fhir:"+parentType+'.'+name);
17953    }
17954    composeBackboneElement(t, "focalDevice", name, element, index);
17955    if (element.hasAction()) {
17956      composeCodeableConcept(t, "ProcedureFocalDeviceComponent", "action", element.getAction(), -1);
17957    }
17958    if (element.hasManipulated()) {
17959      composeReference(t, "ProcedureFocalDeviceComponent", "manipulated", element.getManipulated(), -1);
17960    }
17961  }
17962
17963  protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) {
17964    if (element == null) 
17965      return;
17966    Complex t;
17967    if (Utilities.noString(parentType))
17968      t = parent;
17969    else {
17970      t = parent.predicate("fhir:"+parentType+'.'+name);
17971    }
17972    composeDomainResource(t, "Provenance", name, element, index);
17973    for (int i = 0; i < element.getTarget().size(); i++) {
17974      composeReference(t, "Provenance", "target", element.getTarget().get(i), i);
17975    }
17976    if (element.hasOccurred()) {
17977      composeType(t, "Provenance", "occurred", element.getOccurred(), -1);
17978    }
17979    if (element.hasRecordedElement()) {
17980      composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1);
17981    }
17982    for (int i = 0; i < element.getPolicy().size(); i++) {
17983      composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i);
17984    }
17985    if (element.hasLocation()) {
17986      composeReference(t, "Provenance", "location", element.getLocation(), -1);
17987    }
17988    for (int i = 0; i < element.getReason().size(); i++) {
17989      composeCodeableConcept(t, "Provenance", "reason", element.getReason().get(i), i);
17990    }
17991    if (element.hasActivity()) {
17992      composeCodeableConcept(t, "Provenance", "activity", element.getActivity(), -1);
17993    }
17994    for (int i = 0; i < element.getAgent().size(); i++) {
17995      composeProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i);
17996    }
17997    for (int i = 0; i < element.getEntity().size(); i++) {
17998      composeProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i);
17999    }
18000    for (int i = 0; i < element.getSignature().size(); i++) {
18001      composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i);
18002    }
18003  }
18004
18005  protected void composeProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) {
18006    if (element == null) 
18007      return;
18008    Complex t;
18009    if (Utilities.noString(parentType))
18010      t = parent;
18011    else {
18012      t = parent.predicate("fhir:"+parentType+'.'+name);
18013    }
18014    composeBackboneElement(t, "agent", name, element, index);
18015    if (element.hasType()) {
18016      composeCodeableConcept(t, "ProvenanceAgentComponent", "type", element.getType(), -1);
18017    }
18018    for (int i = 0; i < element.getRole().size(); i++) {
18019      composeCodeableConcept(t, "ProvenanceAgentComponent", "role", element.getRole().get(i), i);
18020    }
18021    if (element.hasWho()) {
18022      composeReference(t, "ProvenanceAgentComponent", "who", element.getWho(), -1);
18023    }
18024    if (element.hasOnBehalfOf()) {
18025      composeReference(t, "ProvenanceAgentComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
18026    }
18027  }
18028
18029  protected void composeProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) {
18030    if (element == null) 
18031      return;
18032    Complex t;
18033    if (Utilities.noString(parentType))
18034      t = parent;
18035    else {
18036      t = parent.predicate("fhir:"+parentType+'.'+name);
18037    }
18038    composeBackboneElement(t, "entity", name, element, index);
18039    if (element.hasRoleElement()) {
18040      composeEnum(t, "ProvenanceEntityComponent", "role", element.getRoleElement(), -1);
18041    }
18042    if (element.hasWhat()) {
18043      composeReference(t, "ProvenanceEntityComponent", "what", element.getWhat(), -1);
18044    }
18045    for (int i = 0; i < element.getAgent().size(); i++) {
18046      composeProvenanceAgentComponent(t, "ProvenanceEntityComponent", "agent", element.getAgent().get(i), i);
18047    }
18048  }
18049
18050  protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) {
18051    if (element == null) 
18052      return;
18053    Complex t;
18054    if (Utilities.noString(parentType))
18055      t = parent;
18056    else {
18057      t = parent.predicate("fhir:"+parentType+'.'+name);
18058    }
18059    composeDomainResource(t, "Questionnaire", name, element, index);
18060    if (element.hasUrlElement()) {
18061      composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1);
18062    }
18063    for (int i = 0; i < element.getIdentifier().size(); i++) {
18064      composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i);
18065    }
18066    if (element.hasVersionElement()) {
18067      composeString(t, "Questionnaire", "version", element.getVersionElement(), -1);
18068    }
18069    if (element.hasNameElement()) {
18070      composeString(t, "Questionnaire", "name", element.getNameElement(), -1);
18071    }
18072    if (element.hasTitleElement()) {
18073      composeString(t, "Questionnaire", "title", element.getTitleElement(), -1);
18074    }
18075    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
18076      composeCanonical(t, "Questionnaire", "derivedFrom", element.getDerivedFrom().get(i), i);
18077    }
18078    if (element.hasStatusElement()) {
18079      composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1);
18080    }
18081    if (element.hasExperimentalElement()) {
18082      composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1);
18083    }
18084    for (int i = 0; i < element.getSubjectType().size(); i++) {
18085      composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i);
18086    }
18087    if (element.hasDateElement()) {
18088      composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1);
18089    }
18090    if (element.hasPublisherElement()) {
18091      composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1);
18092    }
18093    for (int i = 0; i < element.getContact().size(); i++) {
18094      composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i);
18095    }
18096    if (element.hasDescriptionElement()) {
18097      composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1);
18098    }
18099    for (int i = 0; i < element.getUseContext().size(); i++) {
18100      composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i);
18101    }
18102    for (int i = 0; i < element.getJurisdiction().size(); i++) {
18103      composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i);
18104    }
18105    if (element.hasPurposeElement()) {
18106      composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1);
18107    }
18108    if (element.hasCopyrightElement()) {
18109      composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1);
18110    }
18111    if (element.hasApprovalDateElement()) {
18112      composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1);
18113    }
18114    if (element.hasLastReviewDateElement()) {
18115      composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1);
18116    }
18117    if (element.hasEffectivePeriod()) {
18118      composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1);
18119    }
18120    for (int i = 0; i < element.getCode().size(); i++) {
18121      composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i);
18122    }
18123    for (int i = 0; i < element.getItem().size(); i++) {
18124      composeQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i);
18125    }
18126  }
18127
18128  protected void composeQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) {
18129    if (element == null) 
18130      return;
18131    Complex t;
18132    if (Utilities.noString(parentType))
18133      t = parent;
18134    else {
18135      t = parent.predicate("fhir:"+parentType+'.'+name);
18136    }
18137    composeBackboneElement(t, "item", name, element, index);
18138    if (element.hasLinkIdElement()) {
18139      composeString(t, "QuestionnaireItemComponent", "linkId", element.getLinkIdElement(), -1);
18140    }
18141    if (element.hasDefinitionElement()) {
18142      composeUri(t, "QuestionnaireItemComponent", "definition", element.getDefinitionElement(), -1);
18143    }
18144    for (int i = 0; i < element.getCode().size(); i++) {
18145      composeCoding(t, "QuestionnaireItemComponent", "code", element.getCode().get(i), i);
18146    }
18147    if (element.hasPrefixElement()) {
18148      composeString(t, "QuestionnaireItemComponent", "prefix", element.getPrefixElement(), -1);
18149    }
18150    if (element.hasTextElement()) {
18151      composeString(t, "QuestionnaireItemComponent", "text", element.getTextElement(), -1);
18152    }
18153    if (element.hasTypeElement()) {
18154      composeEnum(t, "QuestionnaireItemComponent", "type", element.getTypeElement(), -1);
18155    }
18156    for (int i = 0; i < element.getEnableWhen().size(); i++) {
18157      composeQuestionnaireItemEnableWhenComponent(t, "QuestionnaireItemComponent", "enableWhen", element.getEnableWhen().get(i), i);
18158    }
18159    if (element.hasEnableBehaviorElement()) {
18160      composeEnum(t, "QuestionnaireItemComponent", "enableBehavior", element.getEnableBehaviorElement(), -1);
18161    }
18162    if (element.hasRequiredElement()) {
18163      composeBoolean(t, "QuestionnaireItemComponent", "required", element.getRequiredElement(), -1);
18164    }
18165    if (element.hasRepeatsElement()) {
18166      composeBoolean(t, "QuestionnaireItemComponent", "repeats", element.getRepeatsElement(), -1);
18167    }
18168    if (element.hasReadOnlyElement()) {
18169      composeBoolean(t, "QuestionnaireItemComponent", "readOnly", element.getReadOnlyElement(), -1);
18170    }
18171    if (element.hasMaxLengthElement()) {
18172      composeInteger(t, "QuestionnaireItemComponent", "maxLength", element.getMaxLengthElement(), -1);
18173    }
18174    if (element.hasAnswerValueSetElement()) {
18175      composeCanonical(t, "QuestionnaireItemComponent", "answerValueSet", element.getAnswerValueSetElement(), -1);
18176    }
18177    for (int i = 0; i < element.getAnswerOption().size(); i++) {
18178      composeQuestionnaireItemAnswerOptionComponent(t, "QuestionnaireItemComponent", "answerOption", element.getAnswerOption().get(i), i);
18179    }
18180    for (int i = 0; i < element.getInitial().size(); i++) {
18181      composeQuestionnaireItemInitialComponent(t, "QuestionnaireItemComponent", "initial", element.getInitial().get(i), i);
18182    }
18183    for (int i = 0; i < element.getItem().size(); i++) {
18184      composeQuestionnaireItemComponent(t, "QuestionnaireItemComponent", "item", element.getItem().get(i), i);
18185    }
18186  }
18187
18188  protected void composeQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) {
18189    if (element == null) 
18190      return;
18191    Complex t;
18192    if (Utilities.noString(parentType))
18193      t = parent;
18194    else {
18195      t = parent.predicate("fhir:"+parentType+'.'+name);
18196    }
18197    composeBackboneElement(t, "enableWhen", name, element, index);
18198    if (element.hasQuestionElement()) {
18199      composeString(t, "QuestionnaireItemEnableWhenComponent", "question", element.getQuestionElement(), -1);
18200    }
18201    if (element.hasOperatorElement()) {
18202      composeEnum(t, "QuestionnaireItemEnableWhenComponent", "operator", element.getOperatorElement(), -1);
18203    }
18204    if (element.hasAnswer()) {
18205      composeType(t, "QuestionnaireItemEnableWhenComponent", "answer", element.getAnswer(), -1);
18206    }
18207  }
18208
18209  protected void composeQuestionnaireItemAnswerOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemAnswerOptionComponent element, int index) {
18210    if (element == null) 
18211      return;
18212    Complex t;
18213    if (Utilities.noString(parentType))
18214      t = parent;
18215    else {
18216      t = parent.predicate("fhir:"+parentType+'.'+name);
18217    }
18218    composeBackboneElement(t, "answerOption", name, element, index);
18219    if (element.hasValue()) {
18220      composeType(t, "QuestionnaireItemAnswerOptionComponent", "value", element.getValue(), -1);
18221    }
18222    if (element.hasInitialSelectedElement()) {
18223      composeBoolean(t, "QuestionnaireItemAnswerOptionComponent", "initialSelected", element.getInitialSelectedElement(), -1);
18224    }
18225  }
18226
18227  protected void composeQuestionnaireItemInitialComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemInitialComponent element, int index) {
18228    if (element == null) 
18229      return;
18230    Complex t;
18231    if (Utilities.noString(parentType))
18232      t = parent;
18233    else {
18234      t = parent.predicate("fhir:"+parentType+'.'+name);
18235    }
18236    composeBackboneElement(t, "initial", name, element, index);
18237    if (element.hasValue()) {
18238      composeType(t, "QuestionnaireItemInitialComponent", "value", element.getValue(), -1);
18239    }
18240  }
18241
18242  protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) {
18243    if (element == null) 
18244      return;
18245    Complex t;
18246    if (Utilities.noString(parentType))
18247      t = parent;
18248    else {
18249      t = parent.predicate("fhir:"+parentType+'.'+name);
18250    }
18251    composeDomainResource(t, "QuestionnaireResponse", name, element, index);
18252    if (element.hasIdentifier()) {
18253      composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1);
18254    }
18255    for (int i = 0; i < element.getBasedOn().size(); i++) {
18256      composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i);
18257    }
18258    for (int i = 0; i < element.getPartOf().size(); i++) {
18259      composeReference(t, "QuestionnaireResponse", "partOf", element.getPartOf().get(i), i);
18260    }
18261    if (element.hasQuestionnaireElement()) {
18262      composeCanonical(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaireElement(), -1);
18263    }
18264    if (element.hasStatusElement()) {
18265      composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1);
18266    }
18267    if (element.hasSubject()) {
18268      composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1);
18269    }
18270    if (element.hasEncounter()) {
18271      composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1);
18272    }
18273    if (element.hasAuthoredElement()) {
18274      composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1);
18275    }
18276    if (element.hasAuthor()) {
18277      composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1);
18278    }
18279    if (element.hasSource()) {
18280      composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1);
18281    }
18282    for (int i = 0; i < element.getItem().size(); i++) {
18283      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i);
18284    }
18285  }
18286
18287  protected void composeQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) {
18288    if (element == null) 
18289      return;
18290    Complex t;
18291    if (Utilities.noString(parentType))
18292      t = parent;
18293    else {
18294      t = parent.predicate("fhir:"+parentType+'.'+name);
18295    }
18296    composeBackboneElement(t, "item", name, element, index);
18297    if (element.hasLinkIdElement()) {
18298      composeString(t, "QuestionnaireResponseItemComponent", "linkId", element.getLinkIdElement(), -1);
18299    }
18300    if (element.hasDefinitionElement()) {
18301      composeUri(t, "QuestionnaireResponseItemComponent", "definition", element.getDefinitionElement(), -1);
18302    }
18303    if (element.hasTextElement()) {
18304      composeString(t, "QuestionnaireResponseItemComponent", "text", element.getTextElement(), -1);
18305    }
18306    for (int i = 0; i < element.getAnswer().size(); i++) {
18307      composeQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponseItemComponent", "answer", element.getAnswer().get(i), i);
18308    }
18309    for (int i = 0; i < element.getItem().size(); i++) {
18310      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemComponent", "item", element.getItem().get(i), i);
18311    }
18312  }
18313
18314  protected void composeQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) {
18315    if (element == null) 
18316      return;
18317    Complex t;
18318    if (Utilities.noString(parentType))
18319      t = parent;
18320    else {
18321      t = parent.predicate("fhir:"+parentType+'.'+name);
18322    }
18323    composeBackboneElement(t, "answer", name, element, index);
18324    if (element.hasValue()) {
18325      composeType(t, "QuestionnaireResponseItemAnswerComponent", "value", element.getValue(), -1);
18326    }
18327    for (int i = 0; i < element.getItem().size(); i++) {
18328      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemAnswerComponent", "item", element.getItem().get(i), i);
18329    }
18330  }
18331
18332  protected void composeRegulatedAuthorization(Complex parent, String parentType, String name, RegulatedAuthorization element, int index) {
18333    if (element == null) 
18334      return;
18335    Complex t;
18336    if (Utilities.noString(parentType))
18337      t = parent;
18338    else {
18339      t = parent.predicate("fhir:"+parentType+'.'+name);
18340    }
18341    composeDomainResource(t, "RegulatedAuthorization", name, element, index);
18342    for (int i = 0; i < element.getIdentifier().size(); i++) {
18343      composeIdentifier(t, "RegulatedAuthorization", "identifier", element.getIdentifier().get(i), i);
18344    }
18345    for (int i = 0; i < element.getSubject().size(); i++) {
18346      composeReference(t, "RegulatedAuthorization", "subject", element.getSubject().get(i), i);
18347    }
18348    if (element.hasType()) {
18349      composeCodeableConcept(t, "RegulatedAuthorization", "type", element.getType(), -1);
18350    }
18351    if (element.hasDescriptionElement()) {
18352      composeMarkdown(t, "RegulatedAuthorization", "description", element.getDescriptionElement(), -1);
18353    }
18354    for (int i = 0; i < element.getRegion().size(); i++) {
18355      composeCodeableConcept(t, "RegulatedAuthorization", "region", element.getRegion().get(i), i);
18356    }
18357    if (element.hasStatus()) {
18358      composeCodeableConcept(t, "RegulatedAuthorization", "status", element.getStatus(), -1);
18359    }
18360    if (element.hasStatusDateElement()) {
18361      composeDateTime(t, "RegulatedAuthorization", "statusDate", element.getStatusDateElement(), -1);
18362    }
18363    if (element.hasValidityPeriod()) {
18364      composePeriod(t, "RegulatedAuthorization", "validityPeriod", element.getValidityPeriod(), -1);
18365    }
18366    if (element.hasIndication()) {
18367      composeCodeableReference(t, "RegulatedAuthorization", "indication", element.getIndication(), -1);
18368    }
18369    if (element.hasIntendedUse()) {
18370      composeCodeableConcept(t, "RegulatedAuthorization", "intendedUse", element.getIntendedUse(), -1);
18371    }
18372    for (int i = 0; i < element.getBasis().size(); i++) {
18373      composeCodeableConcept(t, "RegulatedAuthorization", "basis", element.getBasis().get(i), i);
18374    }
18375    if (element.hasHolder()) {
18376      composeReference(t, "RegulatedAuthorization", "holder", element.getHolder(), -1);
18377    }
18378    if (element.hasRegulator()) {
18379      composeReference(t, "RegulatedAuthorization", "regulator", element.getRegulator(), -1);
18380    }
18381    if (element.hasCase()) {
18382      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorization", "case", element.getCase(), -1);
18383    }
18384  }
18385
18386  protected void composeRegulatedAuthorizationCaseComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationCaseComponent element, int index) {
18387    if (element == null) 
18388      return;
18389    Complex t;
18390    if (Utilities.noString(parentType))
18391      t = parent;
18392    else {
18393      t = parent.predicate("fhir:"+parentType+'.'+name);
18394    }
18395    composeBackboneElement(t, "case", name, element, index);
18396    if (element.hasIdentifier()) {
18397      composeIdentifier(t, "RegulatedAuthorizationCaseComponent", "identifier", element.getIdentifier(), -1);
18398    }
18399    if (element.hasType()) {
18400      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "type", element.getType(), -1);
18401    }
18402    if (element.hasStatus()) {
18403      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "status", element.getStatus(), -1);
18404    }
18405    if (element.hasDate()) {
18406      composeType(t, "RegulatedAuthorizationCaseComponent", "date", element.getDate(), -1);
18407    }
18408    for (int i = 0; i < element.getApplication().size(); i++) {
18409      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorizationCaseComponent", "application", element.getApplication().get(i), i);
18410    }
18411  }
18412
18413  protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) {
18414    if (element == null) 
18415      return;
18416    Complex t;
18417    if (Utilities.noString(parentType))
18418      t = parent;
18419    else {
18420      t = parent.predicate("fhir:"+parentType+'.'+name);
18421    }
18422    composeDomainResource(t, "RelatedPerson", name, element, index);
18423    for (int i = 0; i < element.getIdentifier().size(); i++) {
18424      composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i);
18425    }
18426    if (element.hasActiveElement()) {
18427      composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1);
18428    }
18429    if (element.hasPatient()) {
18430      composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1);
18431    }
18432    for (int i = 0; i < element.getRelationship().size(); i++) {
18433      composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship().get(i), i);
18434    }
18435    for (int i = 0; i < element.getName().size(); i++) {
18436      composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i);
18437    }
18438    for (int i = 0; i < element.getTelecom().size(); i++) {
18439      composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i);
18440    }
18441    if (element.hasGenderElement()) {
18442      composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1);
18443    }
18444    if (element.hasBirthDateElement()) {
18445      composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1);
18446    }
18447    for (int i = 0; i < element.getAddress().size(); i++) {
18448      composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i);
18449    }
18450    for (int i = 0; i < element.getPhoto().size(); i++) {
18451      composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i);
18452    }
18453    if (element.hasPeriod()) {
18454      composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1);
18455    }
18456    for (int i = 0; i < element.getCommunication().size(); i++) {
18457      composeRelatedPersonCommunicationComponent(t, "RelatedPerson", "communication", element.getCommunication().get(i), i);
18458    }
18459  }
18460
18461  protected void composeRelatedPersonCommunicationComponent(Complex parent, String parentType, String name, RelatedPerson.RelatedPersonCommunicationComponent element, int index) {
18462    if (element == null) 
18463      return;
18464    Complex t;
18465    if (Utilities.noString(parentType))
18466      t = parent;
18467    else {
18468      t = parent.predicate("fhir:"+parentType+'.'+name);
18469    }
18470    composeBackboneElement(t, "communication", name, element, index);
18471    if (element.hasLanguage()) {
18472      composeCodeableConcept(t, "RelatedPersonCommunicationComponent", "language", element.getLanguage(), -1);
18473    }
18474    if (element.hasPreferredElement()) {
18475      composeBoolean(t, "RelatedPersonCommunicationComponent", "preferred", element.getPreferredElement(), -1);
18476    }
18477  }
18478
18479  protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) {
18480    if (element == null) 
18481      return;
18482    Complex t;
18483    if (Utilities.noString(parentType))
18484      t = parent;
18485    else {
18486      t = parent.predicate("fhir:"+parentType+'.'+name);
18487    }
18488    composeDomainResource(t, "RequestGroup", name, element, index);
18489    for (int i = 0; i < element.getIdentifier().size(); i++) {
18490      composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i);
18491    }
18492    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
18493      composeCanonical(t, "RequestGroup", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
18494    }
18495    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
18496      composeUri(t, "RequestGroup", "instantiatesUri", element.getInstantiatesUri().get(i), i);
18497    }
18498    for (int i = 0; i < element.getBasedOn().size(); i++) {
18499      composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i);
18500    }
18501    for (int i = 0; i < element.getReplaces().size(); i++) {
18502      composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i);
18503    }
18504    if (element.hasGroupIdentifier()) {
18505      composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1);
18506    }
18507    if (element.hasStatusElement()) {
18508      composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1);
18509    }
18510    if (element.hasIntentElement()) {
18511      composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1);
18512    }
18513    if (element.hasPriorityElement()) {
18514      composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1);
18515    }
18516    if (element.hasCode()) {
18517      composeCodeableConcept(t, "RequestGroup", "code", element.getCode(), -1);
18518    }
18519    if (element.hasSubject()) {
18520      composeReference(t, "RequestGroup", "subject", element.getSubject(), -1);
18521    }
18522    if (element.hasEncounter()) {
18523      composeReference(t, "RequestGroup", "encounter", element.getEncounter(), -1);
18524    }
18525    if (element.hasAuthoredOnElement()) {
18526      composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1);
18527    }
18528    if (element.hasAuthor()) {
18529      composeReference(t, "RequestGroup", "author", element.getAuthor(), -1);
18530    }
18531    for (int i = 0; i < element.getReasonCode().size(); i++) {
18532      composeCodeableConcept(t, "RequestGroup", "reasonCode", element.getReasonCode().get(i), i);
18533    }
18534    for (int i = 0; i < element.getReasonReference().size(); i++) {
18535      composeReference(t, "RequestGroup", "reasonReference", element.getReasonReference().get(i), i);
18536    }
18537    for (int i = 0; i < element.getNote().size(); i++) {
18538      composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i);
18539    }
18540    for (int i = 0; i < element.getAction().size(); i++) {
18541      composeRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i);
18542    }
18543  }
18544
18545  protected void composeRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) {
18546    if (element == null) 
18547      return;
18548    Complex t;
18549    if (Utilities.noString(parentType))
18550      t = parent;
18551    else {
18552      t = parent.predicate("fhir:"+parentType+'.'+name);
18553    }
18554    composeBackboneElement(t, "action", name, element, index);
18555    if (element.hasPrefixElement()) {
18556      composeString(t, "RequestGroupActionComponent", "prefix", element.getPrefixElement(), -1);
18557    }
18558    if (element.hasTitleElement()) {
18559      composeString(t, "RequestGroupActionComponent", "title", element.getTitleElement(), -1);
18560    }
18561    if (element.hasDescriptionElement()) {
18562      composeString(t, "RequestGroupActionComponent", "description", element.getDescriptionElement(), -1);
18563    }
18564    if (element.hasTextEquivalentElement()) {
18565      composeString(t, "RequestGroupActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
18566    }
18567    if (element.hasPriorityElement()) {
18568      composeEnum(t, "RequestGroupActionComponent", "priority", element.getPriorityElement(), -1);
18569    }
18570    for (int i = 0; i < element.getCode().size(); i++) {
18571      composeCodeableConcept(t, "RequestGroupActionComponent", "code", element.getCode().get(i), i);
18572    }
18573    for (int i = 0; i < element.getDocumentation().size(); i++) {
18574      composeRelatedArtifact(t, "RequestGroupActionComponent", "documentation", element.getDocumentation().get(i), i);
18575    }
18576    for (int i = 0; i < element.getCondition().size(); i++) {
18577      composeRequestGroupActionConditionComponent(t, "RequestGroupActionComponent", "condition", element.getCondition().get(i), i);
18578    }
18579    for (int i = 0; i < element.getRelatedAction().size(); i++) {
18580      composeRequestGroupActionRelatedActionComponent(t, "RequestGroupActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
18581    }
18582    if (element.hasTiming()) {
18583      composeType(t, "RequestGroupActionComponent", "timing", element.getTiming(), -1);
18584    }
18585    for (int i = 0; i < element.getParticipant().size(); i++) {
18586      composeReference(t, "RequestGroupActionComponent", "participant", element.getParticipant().get(i), i);
18587    }
18588    if (element.hasType()) {
18589      composeCodeableConcept(t, "RequestGroupActionComponent", "type", element.getType(), -1);
18590    }
18591    if (element.hasGroupingBehaviorElement()) {
18592      composeEnum(t, "RequestGroupActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
18593    }
18594    if (element.hasSelectionBehaviorElement()) {
18595      composeEnum(t, "RequestGroupActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
18596    }
18597    if (element.hasRequiredBehaviorElement()) {
18598      composeEnum(t, "RequestGroupActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
18599    }
18600    if (element.hasPrecheckBehaviorElement()) {
18601      composeEnum(t, "RequestGroupActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
18602    }
18603    if (element.hasCardinalityBehaviorElement()) {
18604      composeEnum(t, "RequestGroupActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
18605    }
18606    if (element.hasResource()) {
18607      composeReference(t, "RequestGroupActionComponent", "resource", element.getResource(), -1);
18608    }
18609    for (int i = 0; i < element.getAction().size(); i++) {
18610      composeRequestGroupActionComponent(t, "RequestGroupActionComponent", "action", element.getAction().get(i), i);
18611    }
18612  }
18613
18614  protected void composeRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) {
18615    if (element == null) 
18616      return;
18617    Complex t;
18618    if (Utilities.noString(parentType))
18619      t = parent;
18620    else {
18621      t = parent.predicate("fhir:"+parentType+'.'+name);
18622    }
18623    composeBackboneElement(t, "condition", name, element, index);
18624    if (element.hasKindElement()) {
18625      composeEnum(t, "RequestGroupActionConditionComponent", "kind", element.getKindElement(), -1);
18626    }
18627    if (element.hasExpression()) {
18628      composeExpression(t, "RequestGroupActionConditionComponent", "expression", element.getExpression(), -1);
18629    }
18630  }
18631
18632  protected void composeRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent element, int index) {
18633    if (element == null) 
18634      return;
18635    Complex t;
18636    if (Utilities.noString(parentType))
18637      t = parent;
18638    else {
18639      t = parent.predicate("fhir:"+parentType+'.'+name);
18640    }
18641    composeBackboneElement(t, "relatedAction", name, element, index);
18642    if (element.hasActionIdElement()) {
18643      composeId(t, "RequestGroupActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1);
18644    }
18645    if (element.hasRelationshipElement()) {
18646      composeEnum(t, "RequestGroupActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
18647    }
18648    if (element.hasOffset()) {
18649      composeType(t, "RequestGroupActionRelatedActionComponent", "offset", element.getOffset(), -1);
18650    }
18651  }
18652
18653  protected void composeResearchDefinition(Complex parent, String parentType, String name, ResearchDefinition element, int index) {
18654    if (element == null) 
18655      return;
18656    Complex t;
18657    if (Utilities.noString(parentType))
18658      t = parent;
18659    else {
18660      t = parent.predicate("fhir:"+parentType+'.'+name);
18661    }
18662    composeDomainResource(t, "ResearchDefinition", name, element, index);
18663    if (element.hasUrlElement()) {
18664      composeUri(t, "ResearchDefinition", "url", element.getUrlElement(), -1);
18665    }
18666    for (int i = 0; i < element.getIdentifier().size(); i++) {
18667      composeIdentifier(t, "ResearchDefinition", "identifier", element.getIdentifier().get(i), i);
18668    }
18669    if (element.hasVersionElement()) {
18670      composeString(t, "ResearchDefinition", "version", element.getVersionElement(), -1);
18671    }
18672    if (element.hasNameElement()) {
18673      composeString(t, "ResearchDefinition", "name", element.getNameElement(), -1);
18674    }
18675    if (element.hasTitleElement()) {
18676      composeString(t, "ResearchDefinition", "title", element.getTitleElement(), -1);
18677    }
18678    if (element.hasShortTitleElement()) {
18679      composeString(t, "ResearchDefinition", "shortTitle", element.getShortTitleElement(), -1);
18680    }
18681    if (element.hasSubtitleElement()) {
18682      composeString(t, "ResearchDefinition", "subtitle", element.getSubtitleElement(), -1);
18683    }
18684    if (element.hasStatusElement()) {
18685      composeEnum(t, "ResearchDefinition", "status", element.getStatusElement(), -1);
18686    }
18687    if (element.hasExperimentalElement()) {
18688      composeBoolean(t, "ResearchDefinition", "experimental", element.getExperimentalElement(), -1);
18689    }
18690    if (element.hasSubject()) {
18691      composeType(t, "ResearchDefinition", "subject", element.getSubject(), -1);
18692    }
18693    if (element.hasDateElement()) {
18694      composeDateTime(t, "ResearchDefinition", "date", element.getDateElement(), -1);
18695    }
18696    if (element.hasPublisherElement()) {
18697      composeString(t, "ResearchDefinition", "publisher", element.getPublisherElement(), -1);
18698    }
18699    for (int i = 0; i < element.getContact().size(); i++) {
18700      composeContactDetail(t, "ResearchDefinition", "contact", element.getContact().get(i), i);
18701    }
18702    if (element.hasDescriptionElement()) {
18703      composeMarkdown(t, "ResearchDefinition", "description", element.getDescriptionElement(), -1);
18704    }
18705    for (int i = 0; i < element.getComment().size(); i++) {
18706      composeString(t, "ResearchDefinition", "comment", element.getComment().get(i), i);
18707    }
18708    for (int i = 0; i < element.getUseContext().size(); i++) {
18709      composeUsageContext(t, "ResearchDefinition", "useContext", element.getUseContext().get(i), i);
18710    }
18711    for (int i = 0; i < element.getJurisdiction().size(); i++) {
18712      composeCodeableConcept(t, "ResearchDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
18713    }
18714    if (element.hasPurposeElement()) {
18715      composeMarkdown(t, "ResearchDefinition", "purpose", element.getPurposeElement(), -1);
18716    }
18717    if (element.hasUsageElement()) {
18718      composeString(t, "ResearchDefinition", "usage", element.getUsageElement(), -1);
18719    }
18720    if (element.hasCopyrightElement()) {
18721      composeMarkdown(t, "ResearchDefinition", "copyright", element.getCopyrightElement(), -1);
18722    }
18723    if (element.hasApprovalDateElement()) {
18724      composeDate(t, "ResearchDefinition", "approvalDate", element.getApprovalDateElement(), -1);
18725    }
18726    if (element.hasLastReviewDateElement()) {
18727      composeDate(t, "ResearchDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
18728    }
18729    if (element.hasEffectivePeriod()) {
18730      composePeriod(t, "ResearchDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
18731    }
18732    for (int i = 0; i < element.getTopic().size(); i++) {
18733      composeCodeableConcept(t, "ResearchDefinition", "topic", element.getTopic().get(i), i);
18734    }
18735    for (int i = 0; i < element.getAuthor().size(); i++) {
18736      composeContactDetail(t, "ResearchDefinition", "author", element.getAuthor().get(i), i);
18737    }
18738    for (int i = 0; i < element.getEditor().size(); i++) {
18739      composeContactDetail(t, "ResearchDefinition", "editor", element.getEditor().get(i), i);
18740    }
18741    for (int i = 0; i < element.getReviewer().size(); i++) {
18742      composeContactDetail(t, "ResearchDefinition", "reviewer", element.getReviewer().get(i), i);
18743    }
18744    for (int i = 0; i < element.getEndorser().size(); i++) {
18745      composeContactDetail(t, "ResearchDefinition", "endorser", element.getEndorser().get(i), i);
18746    }
18747    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
18748      composeRelatedArtifact(t, "ResearchDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
18749    }
18750    for (int i = 0; i < element.getLibrary().size(); i++) {
18751      composeCanonical(t, "ResearchDefinition", "library", element.getLibrary().get(i), i);
18752    }
18753    if (element.hasPopulation()) {
18754      composeReference(t, "ResearchDefinition", "population", element.getPopulation(), -1);
18755    }
18756    if (element.hasExposure()) {
18757      composeReference(t, "ResearchDefinition", "exposure", element.getExposure(), -1);
18758    }
18759    if (element.hasExposureAlternative()) {
18760      composeReference(t, "ResearchDefinition", "exposureAlternative", element.getExposureAlternative(), -1);
18761    }
18762    if (element.hasOutcome()) {
18763      composeReference(t, "ResearchDefinition", "outcome", element.getOutcome(), -1);
18764    }
18765  }
18766
18767  protected void composeResearchElementDefinition(Complex parent, String parentType, String name, ResearchElementDefinition element, int index) {
18768    if (element == null) 
18769      return;
18770    Complex t;
18771    if (Utilities.noString(parentType))
18772      t = parent;
18773    else {
18774      t = parent.predicate("fhir:"+parentType+'.'+name);
18775    }
18776    composeDomainResource(t, "ResearchElementDefinition", name, element, index);
18777    if (element.hasUrlElement()) {
18778      composeUri(t, "ResearchElementDefinition", "url", element.getUrlElement(), -1);
18779    }
18780    for (int i = 0; i < element.getIdentifier().size(); i++) {
18781      composeIdentifier(t, "ResearchElementDefinition", "identifier", element.getIdentifier().get(i), i);
18782    }
18783    if (element.hasVersionElement()) {
18784      composeString(t, "ResearchElementDefinition", "version", element.getVersionElement(), -1);
18785    }
18786    if (element.hasNameElement()) {
18787      composeString(t, "ResearchElementDefinition", "name", element.getNameElement(), -1);
18788    }
18789    if (element.hasTitleElement()) {
18790      composeString(t, "ResearchElementDefinition", "title", element.getTitleElement(), -1);
18791    }
18792    if (element.hasShortTitleElement()) {
18793      composeString(t, "ResearchElementDefinition", "shortTitle", element.getShortTitleElement(), -1);
18794    }
18795    if (element.hasSubtitleElement()) {
18796      composeString(t, "ResearchElementDefinition", "subtitle", element.getSubtitleElement(), -1);
18797    }
18798    if (element.hasStatusElement()) {
18799      composeEnum(t, "ResearchElementDefinition", "status", element.getStatusElement(), -1);
18800    }
18801    if (element.hasExperimentalElement()) {
18802      composeBoolean(t, "ResearchElementDefinition", "experimental", element.getExperimentalElement(), -1);
18803    }
18804    if (element.hasSubject()) {
18805      composeType(t, "ResearchElementDefinition", "subject", element.getSubject(), -1);
18806    }
18807    if (element.hasDateElement()) {
18808      composeDateTime(t, "ResearchElementDefinition", "date", element.getDateElement(), -1);
18809    }
18810    if (element.hasPublisherElement()) {
18811      composeString(t, "ResearchElementDefinition", "publisher", element.getPublisherElement(), -1);
18812    }
18813    for (int i = 0; i < element.getContact().size(); i++) {
18814      composeContactDetail(t, "ResearchElementDefinition", "contact", element.getContact().get(i), i);
18815    }
18816    if (element.hasDescriptionElement()) {
18817      composeMarkdown(t, "ResearchElementDefinition", "description", element.getDescriptionElement(), -1);
18818    }
18819    for (int i = 0; i < element.getComment().size(); i++) {
18820      composeString(t, "ResearchElementDefinition", "comment", element.getComment().get(i), i);
18821    }
18822    for (int i = 0; i < element.getUseContext().size(); i++) {
18823      composeUsageContext(t, "ResearchElementDefinition", "useContext", element.getUseContext().get(i), i);
18824    }
18825    for (int i = 0; i < element.getJurisdiction().size(); i++) {
18826      composeCodeableConcept(t, "ResearchElementDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
18827    }
18828    if (element.hasPurposeElement()) {
18829      composeMarkdown(t, "ResearchElementDefinition", "purpose", element.getPurposeElement(), -1);
18830    }
18831    if (element.hasUsageElement()) {
18832      composeString(t, "ResearchElementDefinition", "usage", element.getUsageElement(), -1);
18833    }
18834    if (element.hasCopyrightElement()) {
18835      composeMarkdown(t, "ResearchElementDefinition", "copyright", element.getCopyrightElement(), -1);
18836    }
18837    if (element.hasApprovalDateElement()) {
18838      composeDate(t, "ResearchElementDefinition", "approvalDate", element.getApprovalDateElement(), -1);
18839    }
18840    if (element.hasLastReviewDateElement()) {
18841      composeDate(t, "ResearchElementDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
18842    }
18843    if (element.hasEffectivePeriod()) {
18844      composePeriod(t, "ResearchElementDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
18845    }
18846    for (int i = 0; i < element.getTopic().size(); i++) {
18847      composeCodeableConcept(t, "ResearchElementDefinition", "topic", element.getTopic().get(i), i);
18848    }
18849    for (int i = 0; i < element.getAuthor().size(); i++) {
18850      composeContactDetail(t, "ResearchElementDefinition", "author", element.getAuthor().get(i), i);
18851    }
18852    for (int i = 0; i < element.getEditor().size(); i++) {
18853      composeContactDetail(t, "ResearchElementDefinition", "editor", element.getEditor().get(i), i);
18854    }
18855    for (int i = 0; i < element.getReviewer().size(); i++) {
18856      composeContactDetail(t, "ResearchElementDefinition", "reviewer", element.getReviewer().get(i), i);
18857    }
18858    for (int i = 0; i < element.getEndorser().size(); i++) {
18859      composeContactDetail(t, "ResearchElementDefinition", "endorser", element.getEndorser().get(i), i);
18860    }
18861    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
18862      composeRelatedArtifact(t, "ResearchElementDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
18863    }
18864    for (int i = 0; i < element.getLibrary().size(); i++) {
18865      composeCanonical(t, "ResearchElementDefinition", "library", element.getLibrary().get(i), i);
18866    }
18867    if (element.hasTypeElement()) {
18868      composeEnum(t, "ResearchElementDefinition", "type", element.getTypeElement(), -1);
18869    }
18870    if (element.hasVariableTypeElement()) {
18871      composeEnum(t, "ResearchElementDefinition", "variableType", element.getVariableTypeElement(), -1);
18872    }
18873    for (int i = 0; i < element.getCharacteristic().size(); i++) {
18874      composeResearchElementDefinitionCharacteristicComponent(t, "ResearchElementDefinition", "characteristic", element.getCharacteristic().get(i), i);
18875    }
18876  }
18877
18878  protected void composeResearchElementDefinitionCharacteristicComponent(Complex parent, String parentType, String name, ResearchElementDefinition.ResearchElementDefinitionCharacteristicComponent element, int index) {
18879    if (element == null) 
18880      return;
18881    Complex t;
18882    if (Utilities.noString(parentType))
18883      t = parent;
18884    else {
18885      t = parent.predicate("fhir:"+parentType+'.'+name);
18886    }
18887    composeBackboneElement(t, "characteristic", name, element, index);
18888    if (element.hasDefinition()) {
18889      composeType(t, "ResearchElementDefinitionCharacteristicComponent", "definition", element.getDefinition(), -1);
18890    }
18891    for (int i = 0; i < element.getUsageContext().size(); i++) {
18892      composeUsageContext(t, "ResearchElementDefinitionCharacteristicComponent", "usageContext", element.getUsageContext().get(i), i);
18893    }
18894    if (element.hasExcludeElement()) {
18895      composeBoolean(t, "ResearchElementDefinitionCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
18896    }
18897    if (element.hasUnitOfMeasure()) {
18898      composeCodeableConcept(t, "ResearchElementDefinitionCharacteristicComponent", "unitOfMeasure", element.getUnitOfMeasure(), -1);
18899    }
18900    if (element.hasStudyEffectiveDescriptionElement()) {
18901      composeString(t, "ResearchElementDefinitionCharacteristicComponent", "studyEffectiveDescription", element.getStudyEffectiveDescriptionElement(), -1);
18902    }
18903    if (element.hasStudyEffective()) {
18904      composeType(t, "ResearchElementDefinitionCharacteristicComponent", "studyEffective", element.getStudyEffective(), -1);
18905    }
18906    if (element.hasStudyEffectiveTimeFromStart()) {
18907      composeDuration(t, "ResearchElementDefinitionCharacteristicComponent", "studyEffectiveTimeFromStart", element.getStudyEffectiveTimeFromStart(), -1);
18908    }
18909    if (element.hasStudyEffectiveGroupMeasureElement()) {
18910      composeEnum(t, "ResearchElementDefinitionCharacteristicComponent", "studyEffectiveGroupMeasure", element.getStudyEffectiveGroupMeasureElement(), -1);
18911    }
18912    if (element.hasParticipantEffectiveDescriptionElement()) {
18913      composeString(t, "ResearchElementDefinitionCharacteristicComponent", "participantEffectiveDescription", element.getParticipantEffectiveDescriptionElement(), -1);
18914    }
18915    if (element.hasParticipantEffective()) {
18916      composeType(t, "ResearchElementDefinitionCharacteristicComponent", "participantEffective", element.getParticipantEffective(), -1);
18917    }
18918    if (element.hasParticipantEffectiveTimeFromStart()) {
18919      composeDuration(t, "ResearchElementDefinitionCharacteristicComponent", "participantEffectiveTimeFromStart", element.getParticipantEffectiveTimeFromStart(), -1);
18920    }
18921    if (element.hasParticipantEffectiveGroupMeasureElement()) {
18922      composeEnum(t, "ResearchElementDefinitionCharacteristicComponent", "participantEffectiveGroupMeasure", element.getParticipantEffectiveGroupMeasureElement(), -1);
18923    }
18924  }
18925
18926  protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) {
18927    if (element == null) 
18928      return;
18929    Complex t;
18930    if (Utilities.noString(parentType))
18931      t = parent;
18932    else {
18933      t = parent.predicate("fhir:"+parentType+'.'+name);
18934    }
18935    composeDomainResource(t, "ResearchStudy", name, element, index);
18936    for (int i = 0; i < element.getIdentifier().size(); i++) {
18937      composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i);
18938    }
18939    if (element.hasTitleElement()) {
18940      composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1);
18941    }
18942    for (int i = 0; i < element.getProtocol().size(); i++) {
18943      composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i);
18944    }
18945    for (int i = 0; i < element.getPartOf().size(); i++) {
18946      composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i);
18947    }
18948    if (element.hasStatusElement()) {
18949      composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1);
18950    }
18951    if (element.hasPrimaryPurposeType()) {
18952      composeCodeableConcept(t, "ResearchStudy", "primaryPurposeType", element.getPrimaryPurposeType(), -1);
18953    }
18954    if (element.hasPhase()) {
18955      composeCodeableConcept(t, "ResearchStudy", "phase", element.getPhase(), -1);
18956    }
18957    for (int i = 0; i < element.getCategory().size(); i++) {
18958      composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i);
18959    }
18960    for (int i = 0; i < element.getFocus().size(); i++) {
18961      composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i);
18962    }
18963    for (int i = 0; i < element.getCondition().size(); i++) {
18964      composeCodeableConcept(t, "ResearchStudy", "condition", element.getCondition().get(i), i);
18965    }
18966    for (int i = 0; i < element.getContact().size(); i++) {
18967      composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i);
18968    }
18969    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
18970      composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i);
18971    }
18972    for (int i = 0; i < element.getKeyword().size(); i++) {
18973      composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i);
18974    }
18975    for (int i = 0; i < element.getLocation().size(); i++) {
18976      composeCodeableConcept(t, "ResearchStudy", "location", element.getLocation().get(i), i);
18977    }
18978    if (element.hasDescriptionElement()) {
18979      composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1);
18980    }
18981    for (int i = 0; i < element.getEnrollment().size(); i++) {
18982      composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i);
18983    }
18984    if (element.hasPeriod()) {
18985      composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1);
18986    }
18987    if (element.hasSponsor()) {
18988      composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1);
18989    }
18990    if (element.hasPrincipalInvestigator()) {
18991      composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1);
18992    }
18993    for (int i = 0; i < element.getSite().size(); i++) {
18994      composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i);
18995    }
18996    if (element.hasReasonStopped()) {
18997      composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1);
18998    }
18999    for (int i = 0; i < element.getNote().size(); i++) {
19000      composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i);
19001    }
19002    for (int i = 0; i < element.getArm().size(); i++) {
19003      composeResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i);
19004    }
19005    for (int i = 0; i < element.getObjective().size(); i++) {
19006      composeResearchStudyObjectiveComponent(t, "ResearchStudy", "objective", element.getObjective().get(i), i);
19007    }
19008  }
19009
19010  protected void composeResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) {
19011    if (element == null) 
19012      return;
19013    Complex t;
19014    if (Utilities.noString(parentType))
19015      t = parent;
19016    else {
19017      t = parent.predicate("fhir:"+parentType+'.'+name);
19018    }
19019    composeBackboneElement(t, "arm", name, element, index);
19020    if (element.hasNameElement()) {
19021      composeString(t, "ResearchStudyArmComponent", "name", element.getNameElement(), -1);
19022    }
19023    if (element.hasType()) {
19024      composeCodeableConcept(t, "ResearchStudyArmComponent", "type", element.getType(), -1);
19025    }
19026    if (element.hasDescriptionElement()) {
19027      composeString(t, "ResearchStudyArmComponent", "description", element.getDescriptionElement(), -1);
19028    }
19029  }
19030
19031  protected void composeResearchStudyObjectiveComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyObjectiveComponent element, int index) {
19032    if (element == null) 
19033      return;
19034    Complex t;
19035    if (Utilities.noString(parentType))
19036      t = parent;
19037    else {
19038      t = parent.predicate("fhir:"+parentType+'.'+name);
19039    }
19040    composeBackboneElement(t, "objective", name, element, index);
19041    if (element.hasNameElement()) {
19042      composeString(t, "ResearchStudyObjectiveComponent", "name", element.getNameElement(), -1);
19043    }
19044    if (element.hasType()) {
19045      composeCodeableConcept(t, "ResearchStudyObjectiveComponent", "type", element.getType(), -1);
19046    }
19047  }
19048
19049  protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) {
19050    if (element == null) 
19051      return;
19052    Complex t;
19053    if (Utilities.noString(parentType))
19054      t = parent;
19055    else {
19056      t = parent.predicate("fhir:"+parentType+'.'+name);
19057    }
19058    composeDomainResource(t, "ResearchSubject", name, element, index);
19059    for (int i = 0; i < element.getIdentifier().size(); i++) {
19060      composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier().get(i), i);
19061    }
19062    if (element.hasStatusElement()) {
19063      composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1);
19064    }
19065    if (element.hasPeriod()) {
19066      composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1);
19067    }
19068    if (element.hasStudy()) {
19069      composeReference(t, "ResearchSubject", "study", element.getStudy(), -1);
19070    }
19071    if (element.hasIndividual()) {
19072      composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1);
19073    }
19074    if (element.hasAssignedArmElement()) {
19075      composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1);
19076    }
19077    if (element.hasActualArmElement()) {
19078      composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1);
19079    }
19080    if (element.hasConsent()) {
19081      composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1);
19082    }
19083  }
19084
19085  protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) {
19086    if (element == null) 
19087      return;
19088    Complex t;
19089    if (Utilities.noString(parentType))
19090      t = parent;
19091    else {
19092      t = parent.predicate("fhir:"+parentType+'.'+name);
19093    }
19094    composeDomainResource(t, "RiskAssessment", name, element, index);
19095    for (int i = 0; i < element.getIdentifier().size(); i++) {
19096      composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier().get(i), i);
19097    }
19098    if (element.hasBasedOn()) {
19099      composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1);
19100    }
19101    if (element.hasParent()) {
19102      composeReference(t, "RiskAssessment", "parent", element.getParent(), -1);
19103    }
19104    if (element.hasStatusElement()) {
19105      composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1);
19106    }
19107    if (element.hasMethod()) {
19108      composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1);
19109    }
19110    if (element.hasCode()) {
19111      composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1);
19112    }
19113    if (element.hasSubject()) {
19114      composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1);
19115    }
19116    if (element.hasEncounter()) {
19117      composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1);
19118    }
19119    if (element.hasOccurrence()) {
19120      composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1);
19121    }
19122    if (element.hasCondition()) {
19123      composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1);
19124    }
19125    if (element.hasPerformer()) {
19126      composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1);
19127    }
19128    for (int i = 0; i < element.getReasonCode().size(); i++) {
19129      composeCodeableConcept(t, "RiskAssessment", "reasonCode", element.getReasonCode().get(i), i);
19130    }
19131    for (int i = 0; i < element.getReasonReference().size(); i++) {
19132      composeReference(t, "RiskAssessment", "reasonReference", element.getReasonReference().get(i), i);
19133    }
19134    for (int i = 0; i < element.getBasis().size(); i++) {
19135      composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i);
19136    }
19137    for (int i = 0; i < element.getPrediction().size(); i++) {
19138      composeRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i);
19139    }
19140    if (element.hasMitigationElement()) {
19141      composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1);
19142    }
19143    for (int i = 0; i < element.getNote().size(); i++) {
19144      composeAnnotation(t, "RiskAssessment", "note", element.getNote().get(i), i);
19145    }
19146  }
19147
19148  protected void composeRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) {
19149    if (element == null) 
19150      return;
19151    Complex t;
19152    if (Utilities.noString(parentType))
19153      t = parent;
19154    else {
19155      t = parent.predicate("fhir:"+parentType+'.'+name);
19156    }
19157    composeBackboneElement(t, "prediction", name, element, index);
19158    if (element.hasOutcome()) {
19159      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "outcome", element.getOutcome(), -1);
19160    }
19161    if (element.hasProbability()) {
19162      composeType(t, "RiskAssessmentPredictionComponent", "probability", element.getProbability(), -1);
19163    }
19164    if (element.hasQualitativeRisk()) {
19165      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "qualitativeRisk", element.getQualitativeRisk(), -1);
19166    }
19167    if (element.hasRelativeRiskElement()) {
19168      composeDecimal(t, "RiskAssessmentPredictionComponent", "relativeRisk", element.getRelativeRiskElement(), -1);
19169    }
19170    if (element.hasWhen()) {
19171      composeType(t, "RiskAssessmentPredictionComponent", "when", element.getWhen(), -1);
19172    }
19173    if (element.hasRationaleElement()) {
19174      composeString(t, "RiskAssessmentPredictionComponent", "rationale", element.getRationaleElement(), -1);
19175    }
19176  }
19177
19178  protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) {
19179    if (element == null) 
19180      return;
19181    Complex t;
19182    if (Utilities.noString(parentType))
19183      t = parent;
19184    else {
19185      t = parent.predicate("fhir:"+parentType+'.'+name);
19186    }
19187    composeDomainResource(t, "Schedule", name, element, index);
19188    for (int i = 0; i < element.getIdentifier().size(); i++) {
19189      composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i);
19190    }
19191    if (element.hasActiveElement()) {
19192      composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1);
19193    }
19194    for (int i = 0; i < element.getServiceCategory().size(); i++) {
19195      composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory().get(i), i);
19196    }
19197    for (int i = 0; i < element.getServiceType().size(); i++) {
19198      composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i);
19199    }
19200    for (int i = 0; i < element.getSpecialty().size(); i++) {
19201      composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i);
19202    }
19203    for (int i = 0; i < element.getActor().size(); i++) {
19204      composeReference(t, "Schedule", "actor", element.getActor().get(i), i);
19205    }
19206    if (element.hasPlanningHorizon()) {
19207      composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1);
19208    }
19209    if (element.hasCommentElement()) {
19210      composeString(t, "Schedule", "comment", element.getCommentElement(), -1);
19211    }
19212  }
19213
19214  protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) {
19215    if (element == null) 
19216      return;
19217    Complex t;
19218    if (Utilities.noString(parentType))
19219      t = parent;
19220    else {
19221      t = parent.predicate("fhir:"+parentType+'.'+name);
19222    }
19223    composeDomainResource(t, "SearchParameter", name, element, index);
19224    if (element.hasUrlElement()) {
19225      composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1);
19226    }
19227    if (element.hasVersionElement()) {
19228      composeString(t, "SearchParameter", "version", element.getVersionElement(), -1);
19229    }
19230    if (element.hasNameElement()) {
19231      composeString(t, "SearchParameter", "name", element.getNameElement(), -1);
19232    }
19233    if (element.hasDerivedFromElement()) {
19234      composeCanonical(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1);
19235    }
19236    if (element.hasStatusElement()) {
19237      composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1);
19238    }
19239    if (element.hasExperimentalElement()) {
19240      composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1);
19241    }
19242    if (element.hasDateElement()) {
19243      composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1);
19244    }
19245    if (element.hasPublisherElement()) {
19246      composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1);
19247    }
19248    for (int i = 0; i < element.getContact().size(); i++) {
19249      composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i);
19250    }
19251    if (element.hasDescriptionElement()) {
19252      composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1);
19253    }
19254    for (int i = 0; i < element.getUseContext().size(); i++) {
19255      composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i);
19256    }
19257    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19258      composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i);
19259    }
19260    if (element.hasPurposeElement()) {
19261      composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1);
19262    }
19263    if (element.hasCodeElement()) {
19264      composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1);
19265    }
19266    for (int i = 0; i < element.getBase().size(); i++) {
19267      composeCode(t, "SearchParameter", "base", element.getBase().get(i), i);
19268    }
19269    if (element.hasTypeElement()) {
19270      composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1);
19271    }
19272    if (element.hasExpressionElement()) {
19273      composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1);
19274    }
19275    if (element.hasXpathElement()) {
19276      composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1);
19277    }
19278    if (element.hasXpathUsageElement()) {
19279      composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1);
19280    }
19281    for (int i = 0; i < element.getTarget().size(); i++) {
19282      composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i);
19283    }
19284    if (element.hasMultipleOrElement()) {
19285      composeBoolean(t, "SearchParameter", "multipleOr", element.getMultipleOrElement(), -1);
19286    }
19287    if (element.hasMultipleAndElement()) {
19288      composeBoolean(t, "SearchParameter", "multipleAnd", element.getMultipleAndElement(), -1);
19289    }
19290    for (int i = 0; i < element.getComparator().size(); i++) {
19291      composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i);
19292    }
19293    for (int i = 0; i < element.getModifier().size(); i++) {
19294      composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i);
19295    }
19296    for (int i = 0; i < element.getChain().size(); i++) {
19297      composeString(t, "SearchParameter", "chain", element.getChain().get(i), i);
19298    }
19299    for (int i = 0; i < element.getComponent().size(); i++) {
19300      composeSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i);
19301    }
19302  }
19303
19304  protected void composeSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) {
19305    if (element == null) 
19306      return;
19307    Complex t;
19308    if (Utilities.noString(parentType))
19309      t = parent;
19310    else {
19311      t = parent.predicate("fhir:"+parentType+'.'+name);
19312    }
19313    composeBackboneElement(t, "component", name, element, index);
19314    if (element.hasDefinitionElement()) {
19315      composeCanonical(t, "SearchParameterComponentComponent", "definition", element.getDefinitionElement(), -1);
19316    }
19317    if (element.hasExpressionElement()) {
19318      composeString(t, "SearchParameterComponentComponent", "expression", element.getExpressionElement(), -1);
19319    }
19320  }
19321
19322  protected void composeServiceRequest(Complex parent, String parentType, String name, ServiceRequest element, int index) {
19323    if (element == null) 
19324      return;
19325    Complex t;
19326    if (Utilities.noString(parentType))
19327      t = parent;
19328    else {
19329      t = parent.predicate("fhir:"+parentType+'.'+name);
19330    }
19331    composeDomainResource(t, "ServiceRequest", name, element, index);
19332    for (int i = 0; i < element.getIdentifier().size(); i++) {
19333      composeIdentifier(t, "ServiceRequest", "identifier", element.getIdentifier().get(i), i);
19334    }
19335    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
19336      composeCanonical(t, "ServiceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
19337    }
19338    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
19339      composeUri(t, "ServiceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
19340    }
19341    for (int i = 0; i < element.getBasedOn().size(); i++) {
19342      composeReference(t, "ServiceRequest", "basedOn", element.getBasedOn().get(i), i);
19343    }
19344    for (int i = 0; i < element.getReplaces().size(); i++) {
19345      composeReference(t, "ServiceRequest", "replaces", element.getReplaces().get(i), i);
19346    }
19347    if (element.hasRequisition()) {
19348      composeIdentifier(t, "ServiceRequest", "requisition", element.getRequisition(), -1);
19349    }
19350    if (element.hasStatusElement()) {
19351      composeEnum(t, "ServiceRequest", "status", element.getStatusElement(), -1);
19352    }
19353    if (element.hasIntentElement()) {
19354      composeEnum(t, "ServiceRequest", "intent", element.getIntentElement(), -1);
19355    }
19356    for (int i = 0; i < element.getCategory().size(); i++) {
19357      composeCodeableConcept(t, "ServiceRequest", "category", element.getCategory().get(i), i);
19358    }
19359    if (element.hasPriorityElement()) {
19360      composeEnum(t, "ServiceRequest", "priority", element.getPriorityElement(), -1);
19361    }
19362    if (element.hasDoNotPerformElement()) {
19363      composeBoolean(t, "ServiceRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
19364    }
19365    if (element.hasCode()) {
19366      composeCodeableConcept(t, "ServiceRequest", "code", element.getCode(), -1);
19367    }
19368    for (int i = 0; i < element.getOrderDetail().size(); i++) {
19369      composeCodeableConcept(t, "ServiceRequest", "orderDetail", element.getOrderDetail().get(i), i);
19370    }
19371    if (element.hasQuantity()) {
19372      composeType(t, "ServiceRequest", "quantity", element.getQuantity(), -1);
19373    }
19374    if (element.hasSubject()) {
19375      composeReference(t, "ServiceRequest", "subject", element.getSubject(), -1);
19376    }
19377    if (element.hasEncounter()) {
19378      composeReference(t, "ServiceRequest", "encounter", element.getEncounter(), -1);
19379    }
19380    if (element.hasOccurrence()) {
19381      composeType(t, "ServiceRequest", "occurrence", element.getOccurrence(), -1);
19382    }
19383    if (element.hasAsNeeded()) {
19384      composeType(t, "ServiceRequest", "asNeeded", element.getAsNeeded(), -1);
19385    }
19386    if (element.hasAuthoredOnElement()) {
19387      composeDateTime(t, "ServiceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
19388    }
19389    if (element.hasRequester()) {
19390      composeReference(t, "ServiceRequest", "requester", element.getRequester(), -1);
19391    }
19392    if (element.hasPerformerType()) {
19393      composeCodeableConcept(t, "ServiceRequest", "performerType", element.getPerformerType(), -1);
19394    }
19395    for (int i = 0; i < element.getPerformer().size(); i++) {
19396      composeReference(t, "ServiceRequest", "performer", element.getPerformer().get(i), i);
19397    }
19398    for (int i = 0; i < element.getLocationCode().size(); i++) {
19399      composeCodeableConcept(t, "ServiceRequest", "locationCode", element.getLocationCode().get(i), i);
19400    }
19401    for (int i = 0; i < element.getLocationReference().size(); i++) {
19402      composeReference(t, "ServiceRequest", "locationReference", element.getLocationReference().get(i), i);
19403    }
19404    for (int i = 0; i < element.getReasonCode().size(); i++) {
19405      composeCodeableConcept(t, "ServiceRequest", "reasonCode", element.getReasonCode().get(i), i);
19406    }
19407    for (int i = 0; i < element.getReasonReference().size(); i++) {
19408      composeReference(t, "ServiceRequest", "reasonReference", element.getReasonReference().get(i), i);
19409    }
19410    for (int i = 0; i < element.getInsurance().size(); i++) {
19411      composeReference(t, "ServiceRequest", "insurance", element.getInsurance().get(i), i);
19412    }
19413    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
19414      composeReference(t, "ServiceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
19415    }
19416    for (int i = 0; i < element.getSpecimen().size(); i++) {
19417      composeReference(t, "ServiceRequest", "specimen", element.getSpecimen().get(i), i);
19418    }
19419    for (int i = 0; i < element.getBodySite().size(); i++) {
19420      composeCodeableConcept(t, "ServiceRequest", "bodySite", element.getBodySite().get(i), i);
19421    }
19422    for (int i = 0; i < element.getNote().size(); i++) {
19423      composeAnnotation(t, "ServiceRequest", "note", element.getNote().get(i), i);
19424    }
19425    if (element.hasPatientInstructionElement()) {
19426      composeString(t, "ServiceRequest", "patientInstruction", element.getPatientInstructionElement(), -1);
19427    }
19428    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
19429      composeReference(t, "ServiceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
19430    }
19431  }
19432
19433  protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) {
19434    if (element == null) 
19435      return;
19436    Complex t;
19437    if (Utilities.noString(parentType))
19438      t = parent;
19439    else {
19440      t = parent.predicate("fhir:"+parentType+'.'+name);
19441    }
19442    composeDomainResource(t, "Slot", name, element, index);
19443    for (int i = 0; i < element.getIdentifier().size(); i++) {
19444      composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i);
19445    }
19446    for (int i = 0; i < element.getServiceCategory().size(); i++) {
19447      composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory().get(i), i);
19448    }
19449    for (int i = 0; i < element.getServiceType().size(); i++) {
19450      composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i);
19451    }
19452    for (int i = 0; i < element.getSpecialty().size(); i++) {
19453      composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i);
19454    }
19455    if (element.hasAppointmentType()) {
19456      composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1);
19457    }
19458    if (element.hasSchedule()) {
19459      composeReference(t, "Slot", "schedule", element.getSchedule(), -1);
19460    }
19461    if (element.hasStatusElement()) {
19462      composeEnum(t, "Slot", "status", element.getStatusElement(), -1);
19463    }
19464    if (element.hasStartElement()) {
19465      composeInstant(t, "Slot", "start", element.getStartElement(), -1);
19466    }
19467    if (element.hasEndElement()) {
19468      composeInstant(t, "Slot", "end", element.getEndElement(), -1);
19469    }
19470    if (element.hasOverbookedElement()) {
19471      composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1);
19472    }
19473    if (element.hasCommentElement()) {
19474      composeString(t, "Slot", "comment", element.getCommentElement(), -1);
19475    }
19476  }
19477
19478  protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) {
19479    if (element == null) 
19480      return;
19481    Complex t;
19482    if (Utilities.noString(parentType))
19483      t = parent;
19484    else {
19485      t = parent.predicate("fhir:"+parentType+'.'+name);
19486    }
19487    composeDomainResource(t, "Specimen", name, element, index);
19488    for (int i = 0; i < element.getIdentifier().size(); i++) {
19489      composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i);
19490    }
19491    if (element.hasAccessionIdentifier()) {
19492      composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1);
19493    }
19494    if (element.hasStatusElement()) {
19495      composeEnum(t, "Specimen", "status", element.getStatusElement(), -1);
19496    }
19497    if (element.hasType()) {
19498      composeCodeableConcept(t, "Specimen", "type", element.getType(), -1);
19499    }
19500    if (element.hasSubject()) {
19501      composeReference(t, "Specimen", "subject", element.getSubject(), -1);
19502    }
19503    if (element.hasReceivedTimeElement()) {
19504      composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1);
19505    }
19506    for (int i = 0; i < element.getParent().size(); i++) {
19507      composeReference(t, "Specimen", "parent", element.getParent().get(i), i);
19508    }
19509    for (int i = 0; i < element.getRequest().size(); i++) {
19510      composeReference(t, "Specimen", "request", element.getRequest().get(i), i);
19511    }
19512    if (element.hasCollection()) {
19513      composeSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1);
19514    }
19515    for (int i = 0; i < element.getProcessing().size(); i++) {
19516      composeSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i);
19517    }
19518    for (int i = 0; i < element.getContainer().size(); i++) {
19519      composeSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i);
19520    }
19521    for (int i = 0; i < element.getCondition().size(); i++) {
19522      composeCodeableConcept(t, "Specimen", "condition", element.getCondition().get(i), i);
19523    }
19524    for (int i = 0; i < element.getNote().size(); i++) {
19525      composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i);
19526    }
19527  }
19528
19529  protected void composeSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) {
19530    if (element == null) 
19531      return;
19532    Complex t;
19533    if (Utilities.noString(parentType))
19534      t = parent;
19535    else {
19536      t = parent.predicate("fhir:"+parentType+'.'+name);
19537    }
19538    composeBackboneElement(t, "collection", name, element, index);
19539    if (element.hasCollector()) {
19540      composeReference(t, "SpecimenCollectionComponent", "collector", element.getCollector(), -1);
19541    }
19542    if (element.hasCollected()) {
19543      composeType(t, "SpecimenCollectionComponent", "collected", element.getCollected(), -1);
19544    }
19545    if (element.hasDuration()) {
19546      composeDuration(t, "SpecimenCollectionComponent", "duration", element.getDuration(), -1);
19547    }
19548    if (element.hasQuantity()) {
19549      composeQuantity(t, "SpecimenCollectionComponent", "quantity", element.getQuantity(), -1);
19550    }
19551    if (element.hasMethod()) {
19552      composeCodeableConcept(t, "SpecimenCollectionComponent", "method", element.getMethod(), -1);
19553    }
19554    if (element.hasBodySite()) {
19555      composeCodeableConcept(t, "SpecimenCollectionComponent", "bodySite", element.getBodySite(), -1);
19556    }
19557    if (element.hasFastingStatus()) {
19558      composeType(t, "SpecimenCollectionComponent", "fastingStatus", element.getFastingStatus(), -1);
19559    }
19560  }
19561
19562  protected void composeSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) {
19563    if (element == null) 
19564      return;
19565    Complex t;
19566    if (Utilities.noString(parentType))
19567      t = parent;
19568    else {
19569      t = parent.predicate("fhir:"+parentType+'.'+name);
19570    }
19571    composeBackboneElement(t, "processing", name, element, index);
19572    if (element.hasDescriptionElement()) {
19573      composeString(t, "SpecimenProcessingComponent", "description", element.getDescriptionElement(), -1);
19574    }
19575    if (element.hasProcedure()) {
19576      composeCodeableConcept(t, "SpecimenProcessingComponent", "procedure", element.getProcedure(), -1);
19577    }
19578    for (int i = 0; i < element.getAdditive().size(); i++) {
19579      composeReference(t, "SpecimenProcessingComponent", "additive", element.getAdditive().get(i), i);
19580    }
19581    if (element.hasTime()) {
19582      composeType(t, "SpecimenProcessingComponent", "time", element.getTime(), -1);
19583    }
19584  }
19585
19586  protected void composeSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) {
19587    if (element == null) 
19588      return;
19589    Complex t;
19590    if (Utilities.noString(parentType))
19591      t = parent;
19592    else {
19593      t = parent.predicate("fhir:"+parentType+'.'+name);
19594    }
19595    composeBackboneElement(t, "container", name, element, index);
19596    for (int i = 0; i < element.getIdentifier().size(); i++) {
19597      composeIdentifier(t, "SpecimenContainerComponent", "identifier", element.getIdentifier().get(i), i);
19598    }
19599    if (element.hasDescriptionElement()) {
19600      composeString(t, "SpecimenContainerComponent", "description", element.getDescriptionElement(), -1);
19601    }
19602    if (element.hasType()) {
19603      composeCodeableConcept(t, "SpecimenContainerComponent", "type", element.getType(), -1);
19604    }
19605    if (element.hasCapacity()) {
19606      composeQuantity(t, "SpecimenContainerComponent", "capacity", element.getCapacity(), -1);
19607    }
19608    if (element.hasSpecimenQuantity()) {
19609      composeQuantity(t, "SpecimenContainerComponent", "specimenQuantity", element.getSpecimenQuantity(), -1);
19610    }
19611    if (element.hasAdditive()) {
19612      composeType(t, "SpecimenContainerComponent", "additive", element.getAdditive(), -1);
19613    }
19614  }
19615
19616  protected void composeSpecimenDefinition(Complex parent, String parentType, String name, SpecimenDefinition element, int index) {
19617    if (element == null) 
19618      return;
19619    Complex t;
19620    if (Utilities.noString(parentType))
19621      t = parent;
19622    else {
19623      t = parent.predicate("fhir:"+parentType+'.'+name);
19624    }
19625    composeDomainResource(t, "SpecimenDefinition", name, element, index);
19626    if (element.hasIdentifier()) {
19627      composeIdentifier(t, "SpecimenDefinition", "identifier", element.getIdentifier(), -1);
19628    }
19629    if (element.hasTypeCollected()) {
19630      composeCodeableConcept(t, "SpecimenDefinition", "typeCollected", element.getTypeCollected(), -1);
19631    }
19632    for (int i = 0; i < element.getPatientPreparation().size(); i++) {
19633      composeCodeableConcept(t, "SpecimenDefinition", "patientPreparation", element.getPatientPreparation().get(i), i);
19634    }
19635    if (element.hasTimeAspectElement()) {
19636      composeString(t, "SpecimenDefinition", "timeAspect", element.getTimeAspectElement(), -1);
19637    }
19638    for (int i = 0; i < element.getCollection().size(); i++) {
19639      composeCodeableConcept(t, "SpecimenDefinition", "collection", element.getCollection().get(i), i);
19640    }
19641    for (int i = 0; i < element.getTypeTested().size(); i++) {
19642      composeSpecimenDefinitionTypeTestedComponent(t, "SpecimenDefinition", "typeTested", element.getTypeTested().get(i), i);
19643    }
19644  }
19645
19646  protected void composeSpecimenDefinitionTypeTestedComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedComponent element, int index) {
19647    if (element == null) 
19648      return;
19649    Complex t;
19650    if (Utilities.noString(parentType))
19651      t = parent;
19652    else {
19653      t = parent.predicate("fhir:"+parentType+'.'+name);
19654    }
19655    composeBackboneElement(t, "typeTested", name, element, index);
19656    if (element.hasIsDerivedElement()) {
19657      composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "isDerived", element.getIsDerivedElement(), -1);
19658    }
19659    if (element.hasType()) {
19660      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "type", element.getType(), -1);
19661    }
19662    if (element.hasPreferenceElement()) {
19663      composeEnum(t, "SpecimenDefinitionTypeTestedComponent", "preference", element.getPreferenceElement(), -1);
19664    }
19665    if (element.hasContainer()) {
19666      composeSpecimenDefinitionTypeTestedContainerComponent(t, "SpecimenDefinitionTypeTestedComponent", "container", element.getContainer(), -1);
19667    }
19668    if (element.hasRequirementElement()) {
19669      composeString(t, "SpecimenDefinitionTypeTestedComponent", "requirement", element.getRequirementElement(), -1);
19670    }
19671    if (element.hasRetentionTime()) {
19672      composeDuration(t, "SpecimenDefinitionTypeTestedComponent", "retentionTime", element.getRetentionTime(), -1);
19673    }
19674    for (int i = 0; i < element.getRejectionCriterion().size(); i++) {
19675      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "rejectionCriterion", element.getRejectionCriterion().get(i), i);
19676    }
19677    for (int i = 0; i < element.getHandling().size(); i++) {
19678      composeSpecimenDefinitionTypeTestedHandlingComponent(t, "SpecimenDefinitionTypeTestedComponent", "handling", element.getHandling().get(i), i);
19679    }
19680  }
19681
19682  protected void composeSpecimenDefinitionTypeTestedContainerComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerComponent element, int index) {
19683    if (element == null) 
19684      return;
19685    Complex t;
19686    if (Utilities.noString(parentType))
19687      t = parent;
19688    else {
19689      t = parent.predicate("fhir:"+parentType+'.'+name);
19690    }
19691    composeBackboneElement(t, "container", name, element, index);
19692    if (element.hasMaterial()) {
19693      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "material", element.getMaterial(), -1);
19694    }
19695    if (element.hasType()) {
19696      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "type", element.getType(), -1);
19697    }
19698    if (element.hasCap()) {
19699      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "cap", element.getCap(), -1);
19700    }
19701    if (element.hasDescriptionElement()) {
19702      composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "description", element.getDescriptionElement(), -1);
19703    }
19704    if (element.hasCapacity()) {
19705      composeQuantity(t, "SpecimenDefinitionTypeTestedContainerComponent", "capacity", element.getCapacity(), -1);
19706    }
19707    if (element.hasMinimumVolume()) {
19708      composeType(t, "SpecimenDefinitionTypeTestedContainerComponent", "minimumVolume", element.getMinimumVolume(), -1);
19709    }
19710    for (int i = 0; i < element.getAdditive().size(); i++) {
19711      composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(t, "SpecimenDefinitionTypeTestedContainerComponent", "additive", element.getAdditive().get(i), i);
19712    }
19713    if (element.hasPreparationElement()) {
19714      composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "preparation", element.getPreparationElement(), -1);
19715    }
19716  }
19717
19718  protected void composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerAdditiveComponent element, int index) {
19719    if (element == null) 
19720      return;
19721    Complex t;
19722    if (Utilities.noString(parentType))
19723      t = parent;
19724    else {
19725      t = parent.predicate("fhir:"+parentType+'.'+name);
19726    }
19727    composeBackboneElement(t, "additive", name, element, index);
19728    if (element.hasAdditive()) {
19729      composeType(t, "SpecimenDefinitionTypeTestedContainerAdditiveComponent", "additive", element.getAdditive(), -1);
19730    }
19731  }
19732
19733  protected void composeSpecimenDefinitionTypeTestedHandlingComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedHandlingComponent element, int index) {
19734    if (element == null) 
19735      return;
19736    Complex t;
19737    if (Utilities.noString(parentType))
19738      t = parent;
19739    else {
19740      t = parent.predicate("fhir:"+parentType+'.'+name);
19741    }
19742    composeBackboneElement(t, "handling", name, element, index);
19743    if (element.hasTemperatureQualifier()) {
19744      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureQualifier", element.getTemperatureQualifier(), -1);
19745    }
19746    if (element.hasTemperatureRange()) {
19747      composeRange(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureRange", element.getTemperatureRange(), -1);
19748    }
19749    if (element.hasMaxDuration()) {
19750      composeDuration(t, "SpecimenDefinitionTypeTestedHandlingComponent", "maxDuration", element.getMaxDuration(), -1);
19751    }
19752    if (element.hasInstructionElement()) {
19753      composeString(t, "SpecimenDefinitionTypeTestedHandlingComponent", "instruction", element.getInstructionElement(), -1);
19754    }
19755  }
19756
19757  protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) {
19758    if (element == null) 
19759      return;
19760    Complex t;
19761    if (Utilities.noString(parentType))
19762      t = parent;
19763    else {
19764      t = parent.predicate("fhir:"+parentType+'.'+name);
19765    }
19766    composeDomainResource(t, "StructureDefinition", name, element, index);
19767    if (element.hasUrlElement()) {
19768      composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1);
19769    }
19770    for (int i = 0; i < element.getIdentifier().size(); i++) {
19771      composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i);
19772    }
19773    if (element.hasVersionElement()) {
19774      composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1);
19775    }
19776    if (element.hasNameElement()) {
19777      composeString(t, "StructureDefinition", "name", element.getNameElement(), -1);
19778    }
19779    if (element.hasTitleElement()) {
19780      composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1);
19781    }
19782    if (element.hasStatusElement()) {
19783      composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1);
19784    }
19785    if (element.hasExperimentalElement()) {
19786      composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1);
19787    }
19788    if (element.hasDateElement()) {
19789      composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1);
19790    }
19791    if (element.hasPublisherElement()) {
19792      composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1);
19793    }
19794    for (int i = 0; i < element.getContact().size(); i++) {
19795      composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i);
19796    }
19797    if (element.hasDescriptionElement()) {
19798      composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1);
19799    }
19800    for (int i = 0; i < element.getUseContext().size(); i++) {
19801      composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i);
19802    }
19803    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19804      composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
19805    }
19806    if (element.hasPurposeElement()) {
19807      composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1);
19808    }
19809    if (element.hasCopyrightElement()) {
19810      composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1);
19811    }
19812    for (int i = 0; i < element.getKeyword().size(); i++) {
19813      composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i);
19814    }
19815    if (element.hasFhirVersionElement()) {
19816      composeEnum(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1);
19817    }
19818    for (int i = 0; i < element.getMapping().size(); i++) {
19819      composeStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i);
19820    }
19821    if (element.hasKindElement()) {
19822      composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1);
19823    }
19824    if (element.hasAbstractElement()) {
19825      composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1);
19826    }
19827    for (int i = 0; i < element.getContext().size(); i++) {
19828      composeStructureDefinitionContextComponent(t, "StructureDefinition", "context", element.getContext().get(i), i);
19829    }
19830    for (int i = 0; i < element.getContextInvariant().size(); i++) {
19831      composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i);
19832    }
19833    if (element.hasTypeElement()) {
19834      composeUri(t, "StructureDefinition", "type", element.getTypeElement(), -1);
19835    }
19836    if (element.hasBaseDefinitionElement()) {
19837      composeCanonical(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1);
19838    }
19839    if (element.hasDerivationElement()) {
19840      composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1);
19841    }
19842    if (element.hasSnapshot()) {
19843      composeStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1);
19844    }
19845    if (element.hasDifferential()) {
19846      composeStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1);
19847    }
19848  }
19849
19850  protected void composeStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) {
19851    if (element == null) 
19852      return;
19853    Complex t;
19854    if (Utilities.noString(parentType))
19855      t = parent;
19856    else {
19857      t = parent.predicate("fhir:"+parentType+'.'+name);
19858    }
19859    composeBackboneElement(t, "mapping", name, element, index);
19860    if (element.hasIdentityElement()) {
19861      composeId(t, "StructureDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
19862    }
19863    if (element.hasUriElement()) {
19864      composeUri(t, "StructureDefinitionMappingComponent", "uri", element.getUriElement(), -1);
19865    }
19866    if (element.hasNameElement()) {
19867      composeString(t, "StructureDefinitionMappingComponent", "name", element.getNameElement(), -1);
19868    }
19869    if (element.hasCommentElement()) {
19870      composeString(t, "StructureDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
19871    }
19872  }
19873
19874  protected void composeStructureDefinitionContextComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContextComponent element, int index) {
19875    if (element == null) 
19876      return;
19877    Complex t;
19878    if (Utilities.noString(parentType))
19879      t = parent;
19880    else {
19881      t = parent.predicate("fhir:"+parentType+'.'+name);
19882    }
19883    composeBackboneElement(t, "context", name, element, index);
19884    if (element.hasTypeElement()) {
19885      composeEnum(t, "StructureDefinitionContextComponent", "type", element.getTypeElement(), -1);
19886    }
19887    if (element.hasExpressionElement()) {
19888      composeString(t, "StructureDefinitionContextComponent", "expression", element.getExpressionElement(), -1);
19889    }
19890  }
19891
19892  protected void composeStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) {
19893    if (element == null) 
19894      return;
19895    Complex t;
19896    if (Utilities.noString(parentType))
19897      t = parent;
19898    else {
19899      t = parent.predicate("fhir:"+parentType+'.'+name);
19900    }
19901    composeBackboneElement(t, "snapshot", name, element, index);
19902    for (int i = 0; i < element.getElement().size(); i++) {
19903      composeElementDefinition(t, "StructureDefinitionSnapshotComponent", "element", element.getElement().get(i), i);
19904    }
19905  }
19906
19907  protected void composeStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) {
19908    if (element == null) 
19909      return;
19910    Complex t;
19911    if (Utilities.noString(parentType))
19912      t = parent;
19913    else {
19914      t = parent.predicate("fhir:"+parentType+'.'+name);
19915    }
19916    composeBackboneElement(t, "differential", name, element, index);
19917    for (int i = 0; i < element.getElement().size(); i++) {
19918      composeElementDefinition(t, "StructureDefinitionDifferentialComponent", "element", element.getElement().get(i), i);
19919    }
19920  }
19921
19922  protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) {
19923    if (element == null) 
19924      return;
19925    Complex t;
19926    if (Utilities.noString(parentType))
19927      t = parent;
19928    else {
19929      t = parent.predicate("fhir:"+parentType+'.'+name);
19930    }
19931    composeDomainResource(t, "StructureMap", name, element, index);
19932    if (element.hasUrlElement()) {
19933      composeUri(t, "StructureMap", "url", element.getUrlElement(), -1);
19934    }
19935    for (int i = 0; i < element.getIdentifier().size(); i++) {
19936      composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i);
19937    }
19938    if (element.hasVersionElement()) {
19939      composeString(t, "StructureMap", "version", element.getVersionElement(), -1);
19940    }
19941    if (element.hasNameElement()) {
19942      composeString(t, "StructureMap", "name", element.getNameElement(), -1);
19943    }
19944    if (element.hasTitleElement()) {
19945      composeString(t, "StructureMap", "title", element.getTitleElement(), -1);
19946    }
19947    if (element.hasStatusElement()) {
19948      composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1);
19949    }
19950    if (element.hasExperimentalElement()) {
19951      composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1);
19952    }
19953    if (element.hasDateElement()) {
19954      composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1);
19955    }
19956    if (element.hasPublisherElement()) {
19957      composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1);
19958    }
19959    for (int i = 0; i < element.getContact().size(); i++) {
19960      composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i);
19961    }
19962    if (element.hasDescriptionElement()) {
19963      composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1);
19964    }
19965    for (int i = 0; i < element.getUseContext().size(); i++) {
19966      composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i);
19967    }
19968    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19969      composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i);
19970    }
19971    if (element.hasPurposeElement()) {
19972      composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1);
19973    }
19974    if (element.hasCopyrightElement()) {
19975      composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1);
19976    }
19977    for (int i = 0; i < element.getStructure().size(); i++) {
19978      composeStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i);
19979    }
19980    for (int i = 0; i < element.getImport().size(); i++) {
19981      composeCanonical(t, "StructureMap", "import", element.getImport().get(i), i);
19982    }
19983    for (int i = 0; i < element.getGroup().size(); i++) {
19984      composeStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i);
19985    }
19986  }
19987
19988  protected void composeStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) {
19989    if (element == null) 
19990      return;
19991    Complex t;
19992    if (Utilities.noString(parentType))
19993      t = parent;
19994    else {
19995      t = parent.predicate("fhir:"+parentType+'.'+name);
19996    }
19997    composeBackboneElement(t, "structure", name, element, index);
19998    if (element.hasUrlElement()) {
19999      composeCanonical(t, "StructureMapStructureComponent", "url", element.getUrlElement(), -1);
20000    }
20001    if (element.hasModeElement()) {
20002      composeEnum(t, "StructureMapStructureComponent", "mode", element.getModeElement(), -1);
20003    }
20004    if (element.hasAliasElement()) {
20005      composeString(t, "StructureMapStructureComponent", "alias", element.getAliasElement(), -1);
20006    }
20007    if (element.hasDocumentationElement()) {
20008      composeString(t, "StructureMapStructureComponent", "documentation", element.getDocumentationElement(), -1);
20009    }
20010  }
20011
20012  protected void composeStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) {
20013    if (element == null) 
20014      return;
20015    Complex t;
20016    if (Utilities.noString(parentType))
20017      t = parent;
20018    else {
20019      t = parent.predicate("fhir:"+parentType+'.'+name);
20020    }
20021    composeBackboneElement(t, "group", name, element, index);
20022    if (element.hasNameElement()) {
20023      composeId(t, "StructureMapGroupComponent", "name", element.getNameElement(), -1);
20024    }
20025    if (element.hasExtendsElement()) {
20026      composeId(t, "StructureMapGroupComponent", "extends", element.getExtendsElement(), -1);
20027    }
20028    if (element.hasTypeModeElement()) {
20029      composeEnum(t, "StructureMapGroupComponent", "typeMode", element.getTypeModeElement(), -1);
20030    }
20031    if (element.hasDocumentationElement()) {
20032      composeString(t, "StructureMapGroupComponent", "documentation", element.getDocumentationElement(), -1);
20033    }
20034    for (int i = 0; i < element.getInput().size(); i++) {
20035      composeStructureMapGroupInputComponent(t, "StructureMapGroupComponent", "input", element.getInput().get(i), i);
20036    }
20037    for (int i = 0; i < element.getRule().size(); i++) {
20038      composeStructureMapGroupRuleComponent(t, "StructureMapGroupComponent", "rule", element.getRule().get(i), i);
20039    }
20040  }
20041
20042  protected void composeStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) {
20043    if (element == null) 
20044      return;
20045    Complex t;
20046    if (Utilities.noString(parentType))
20047      t = parent;
20048    else {
20049      t = parent.predicate("fhir:"+parentType+'.'+name);
20050    }
20051    composeBackboneElement(t, "input", name, element, index);
20052    if (element.hasNameElement()) {
20053      composeId(t, "StructureMapGroupInputComponent", "name", element.getNameElement(), -1);
20054    }
20055    if (element.hasTypeElement()) {
20056      composeString(t, "StructureMapGroupInputComponent", "type", element.getTypeElement(), -1);
20057    }
20058    if (element.hasModeElement()) {
20059      composeEnum(t, "StructureMapGroupInputComponent", "mode", element.getModeElement(), -1);
20060    }
20061    if (element.hasDocumentationElement()) {
20062      composeString(t, "StructureMapGroupInputComponent", "documentation", element.getDocumentationElement(), -1);
20063    }
20064  }
20065
20066  protected void composeStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) {
20067    if (element == null) 
20068      return;
20069    Complex t;
20070    if (Utilities.noString(parentType))
20071      t = parent;
20072    else {
20073      t = parent.predicate("fhir:"+parentType+'.'+name);
20074    }
20075    composeBackboneElement(t, "rule", name, element, index);
20076    if (element.hasNameElement()) {
20077      composeId(t, "StructureMapGroupRuleComponent", "name", element.getNameElement(), -1);
20078    }
20079    for (int i = 0; i < element.getSource().size(); i++) {
20080      composeStructureMapGroupRuleSourceComponent(t, "StructureMapGroupRuleComponent", "source", element.getSource().get(i), i);
20081    }
20082    for (int i = 0; i < element.getTarget().size(); i++) {
20083      composeStructureMapGroupRuleTargetComponent(t, "StructureMapGroupRuleComponent", "target", element.getTarget().get(i), i);
20084    }
20085    for (int i = 0; i < element.getRule().size(); i++) {
20086      composeStructureMapGroupRuleComponent(t, "StructureMapGroupRuleComponent", "rule", element.getRule().get(i), i);
20087    }
20088    for (int i = 0; i < element.getDependent().size(); i++) {
20089      composeStructureMapGroupRuleDependentComponent(t, "StructureMapGroupRuleComponent", "dependent", element.getDependent().get(i), i);
20090    }
20091    if (element.hasDocumentationElement()) {
20092      composeString(t, "StructureMapGroupRuleComponent", "documentation", element.getDocumentationElement(), -1);
20093    }
20094  }
20095
20096  protected void composeStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) {
20097    if (element == null) 
20098      return;
20099    Complex t;
20100    if (Utilities.noString(parentType))
20101      t = parent;
20102    else {
20103      t = parent.predicate("fhir:"+parentType+'.'+name);
20104    }
20105    composeBackboneElement(t, "source", name, element, index);
20106    if (element.hasContextElement()) {
20107      composeId(t, "StructureMapGroupRuleSourceComponent", "context", element.getContextElement(), -1);
20108    }
20109    if (element.hasMinElement()) {
20110      composeInteger(t, "StructureMapGroupRuleSourceComponent", "min", element.getMinElement(), -1);
20111    }
20112    if (element.hasMaxElement()) {
20113      composeString(t, "StructureMapGroupRuleSourceComponent", "max", element.getMaxElement(), -1);
20114    }
20115    if (element.hasTypeElement()) {
20116      composeString(t, "StructureMapGroupRuleSourceComponent", "type", element.getTypeElement(), -1);
20117    }
20118    if (element.hasDefaultValue()) {
20119      composeType(t, "StructureMapGroupRuleSourceComponent", "defaultValue", element.getDefaultValue(), -1);
20120    }
20121    if (element.hasElementElement()) {
20122      composeString(t, "StructureMapGroupRuleSourceComponent", "element", element.getElementElement(), -1);
20123    }
20124    if (element.hasListModeElement()) {
20125      composeEnum(t, "StructureMapGroupRuleSourceComponent", "listMode", element.getListModeElement(), -1);
20126    }
20127    if (element.hasVariableElement()) {
20128      composeId(t, "StructureMapGroupRuleSourceComponent", "variable", element.getVariableElement(), -1);
20129    }
20130    if (element.hasConditionElement()) {
20131      composeString(t, "StructureMapGroupRuleSourceComponent", "condition", element.getConditionElement(), -1);
20132    }
20133    if (element.hasCheckElement()) {
20134      composeString(t, "StructureMapGroupRuleSourceComponent", "check", element.getCheckElement(), -1);
20135    }
20136    if (element.hasLogMessageElement()) {
20137      composeString(t, "StructureMapGroupRuleSourceComponent", "logMessage", element.getLogMessageElement(), -1);
20138    }
20139  }
20140
20141  protected void composeStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) {
20142    if (element == null) 
20143      return;
20144    Complex t;
20145    if (Utilities.noString(parentType))
20146      t = parent;
20147    else {
20148      t = parent.predicate("fhir:"+parentType+'.'+name);
20149    }
20150    composeBackboneElement(t, "target", name, element, index);
20151    if (element.hasContextElement()) {
20152      composeId(t, "StructureMapGroupRuleTargetComponent", "context", element.getContextElement(), -1);
20153    }
20154    if (element.hasContextTypeElement()) {
20155      composeEnum(t, "StructureMapGroupRuleTargetComponent", "contextType", element.getContextTypeElement(), -1);
20156    }
20157    if (element.hasElementElement()) {
20158      composeString(t, "StructureMapGroupRuleTargetComponent", "element", element.getElementElement(), -1);
20159    }
20160    if (element.hasVariableElement()) {
20161      composeId(t, "StructureMapGroupRuleTargetComponent", "variable", element.getVariableElement(), -1);
20162    }
20163    for (int i = 0; i < element.getListMode().size(); i++) {
20164      composeEnum(t, "StructureMapGroupRuleTargetComponent", "listMode", element.getListMode().get(i), i);
20165    }
20166    if (element.hasListRuleIdElement()) {
20167      composeId(t, "StructureMapGroupRuleTargetComponent", "listRuleId", element.getListRuleIdElement(), -1);
20168    }
20169    if (element.hasTransformElement()) {
20170      composeEnum(t, "StructureMapGroupRuleTargetComponent", "transform", element.getTransformElement(), -1);
20171    }
20172    for (int i = 0; i < element.getParameter().size(); i++) {
20173      composeStructureMapGroupRuleTargetParameterComponent(t, "StructureMapGroupRuleTargetComponent", "parameter", element.getParameter().get(i), i);
20174    }
20175  }
20176
20177  protected void composeStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) {
20178    if (element == null) 
20179      return;
20180    Complex t;
20181    if (Utilities.noString(parentType))
20182      t = parent;
20183    else {
20184      t = parent.predicate("fhir:"+parentType+'.'+name);
20185    }
20186    composeBackboneElement(t, "parameter", name, element, index);
20187    if (element.hasValue()) {
20188      composeType(t, "StructureMapGroupRuleTargetParameterComponent", "value", element.getValue(), -1);
20189    }
20190  }
20191
20192  protected void composeStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) {
20193    if (element == null) 
20194      return;
20195    Complex t;
20196    if (Utilities.noString(parentType))
20197      t = parent;
20198    else {
20199      t = parent.predicate("fhir:"+parentType+'.'+name);
20200    }
20201    composeBackboneElement(t, "dependent", name, element, index);
20202    if (element.hasNameElement()) {
20203      composeId(t, "StructureMapGroupRuleDependentComponent", "name", element.getNameElement(), -1);
20204    }
20205    for (int i = 0; i < element.getVariable().size(); i++) {
20206      composeString(t, "StructureMapGroupRuleDependentComponent", "variable", element.getVariable().get(i), i);
20207    }
20208  }
20209
20210  protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) {
20211    if (element == null) 
20212      return;
20213    Complex t;
20214    if (Utilities.noString(parentType))
20215      t = parent;
20216    else {
20217      t = parent.predicate("fhir:"+parentType+'.'+name);
20218    }
20219    composeDomainResource(t, "Subscription", name, element, index);
20220    if (element.hasStatusElement()) {
20221      composeEnum(t, "Subscription", "status", element.getStatusElement(), -1);
20222    }
20223    for (int i = 0; i < element.getContact().size(); i++) {
20224      composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i);
20225    }
20226    if (element.hasEndElement()) {
20227      composeInstant(t, "Subscription", "end", element.getEndElement(), -1);
20228    }
20229    if (element.hasReasonElement()) {
20230      composeString(t, "Subscription", "reason", element.getReasonElement(), -1);
20231    }
20232    if (element.hasCriteriaElement()) {
20233      composeString(t, "Subscription", "criteria", element.getCriteriaElement(), -1);
20234    }
20235    if (element.hasErrorElement()) {
20236      composeString(t, "Subscription", "error", element.getErrorElement(), -1);
20237    }
20238    if (element.hasChannel()) {
20239      composeSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1);
20240    }
20241  }
20242
20243  protected void composeSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) {
20244    if (element == null) 
20245      return;
20246    Complex t;
20247    if (Utilities.noString(parentType))
20248      t = parent;
20249    else {
20250      t = parent.predicate("fhir:"+parentType+'.'+name);
20251    }
20252    composeBackboneElement(t, "channel", name, element, index);
20253    if (element.hasTypeElement()) {
20254      composeEnum(t, "SubscriptionChannelComponent", "type", element.getTypeElement(), -1);
20255    }
20256    if (element.hasEndpointElement()) {
20257      composeUrl(t, "SubscriptionChannelComponent", "endpoint", element.getEndpointElement(), -1);
20258    }
20259    if (element.hasPayloadElement()) {
20260      composeCode(t, "SubscriptionChannelComponent", "payload", element.getPayloadElement(), -1);
20261    }
20262    for (int i = 0; i < element.getHeader().size(); i++) {
20263      composeString(t, "SubscriptionChannelComponent", "header", element.getHeader().get(i), i);
20264    }
20265  }
20266
20267  protected void composeSubscriptionStatus(Complex parent, String parentType, String name, SubscriptionStatus element, int index) {
20268    if (element == null) 
20269      return;
20270    Complex t;
20271    if (Utilities.noString(parentType))
20272      t = parent;
20273    else {
20274      t = parent.predicate("fhir:"+parentType+'.'+name);
20275    }
20276    composeDomainResource(t, "SubscriptionStatus", name, element, index);
20277    if (element.hasStatusElement()) {
20278      composeEnum(t, "SubscriptionStatus", "status", element.getStatusElement(), -1);
20279    }
20280    if (element.hasTypeElement()) {
20281      composeEnum(t, "SubscriptionStatus", "type", element.getTypeElement(), -1);
20282    }
20283    if (element.hasEventsSinceSubscriptionStartElement()) {
20284      composeString(t, "SubscriptionStatus", "eventsSinceSubscriptionStart", element.getEventsSinceSubscriptionStartElement(), -1);
20285    }
20286    if (element.hasEventsInNotificationElement()) {
20287      composeInteger(t, "SubscriptionStatus", "eventsInNotification", element.getEventsInNotificationElement(), -1);
20288    }
20289    for (int i = 0; i < element.getNotificationEvent().size(); i++) {
20290      composeSubscriptionStatusNotificationEventComponent(t, "SubscriptionStatus", "notificationEvent", element.getNotificationEvent().get(i), i);
20291    }
20292    if (element.hasSubscription()) {
20293      composeReference(t, "SubscriptionStatus", "subscription", element.getSubscription(), -1);
20294    }
20295    if (element.hasTopicElement()) {
20296      composeCanonical(t, "SubscriptionStatus", "topic", element.getTopicElement(), -1);
20297    }
20298    for (int i = 0; i < element.getError().size(); i++) {
20299      composeCodeableConcept(t, "SubscriptionStatus", "error", element.getError().get(i), i);
20300    }
20301  }
20302
20303  protected void composeSubscriptionStatusNotificationEventComponent(Complex parent, String parentType, String name, SubscriptionStatus.SubscriptionStatusNotificationEventComponent element, int index) {
20304    if (element == null) 
20305      return;
20306    Complex t;
20307    if (Utilities.noString(parentType))
20308      t = parent;
20309    else {
20310      t = parent.predicate("fhir:"+parentType+'.'+name);
20311    }
20312    composeBackboneElement(t, "notificationEvent", name, element, index);
20313    if (element.hasEventNumberElement()) {
20314      composeString(t, "SubscriptionStatusNotificationEventComponent", "eventNumber", element.getEventNumberElement(), -1);
20315    }
20316    if (element.hasTimestampElement()) {
20317      composeInstant(t, "SubscriptionStatusNotificationEventComponent", "timestamp", element.getTimestampElement(), -1);
20318    }
20319    if (element.hasFocus()) {
20320      composeReference(t, "SubscriptionStatusNotificationEventComponent", "focus", element.getFocus(), -1);
20321    }
20322    for (int i = 0; i < element.getAdditionalContext().size(); i++) {
20323      composeReference(t, "SubscriptionStatusNotificationEventComponent", "additionalContext", element.getAdditionalContext().get(i), i);
20324    }
20325  }
20326
20327  protected void composeSubscriptionTopic(Complex parent, String parentType, String name, SubscriptionTopic element, int index) {
20328    if (element == null) 
20329      return;
20330    Complex t;
20331    if (Utilities.noString(parentType))
20332      t = parent;
20333    else {
20334      t = parent.predicate("fhir:"+parentType+'.'+name);
20335    }
20336    composeDomainResource(t, "SubscriptionTopic", name, element, index);
20337    if (element.hasUrlElement()) {
20338      composeUri(t, "SubscriptionTopic", "url", element.getUrlElement(), -1);
20339    }
20340    for (int i = 0; i < element.getIdentifier().size(); i++) {
20341      composeIdentifier(t, "SubscriptionTopic", "identifier", element.getIdentifier().get(i), i);
20342    }
20343    if (element.hasVersionElement()) {
20344      composeString(t, "SubscriptionTopic", "version", element.getVersionElement(), -1);
20345    }
20346    if (element.hasTitleElement()) {
20347      composeString(t, "SubscriptionTopic", "title", element.getTitleElement(), -1);
20348    }
20349    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
20350      composeCanonical(t, "SubscriptionTopic", "derivedFrom", element.getDerivedFrom().get(i), i);
20351    }
20352    if (element.hasStatusElement()) {
20353      composeEnum(t, "SubscriptionTopic", "status", element.getStatusElement(), -1);
20354    }
20355    if (element.hasExperimentalElement()) {
20356      composeBoolean(t, "SubscriptionTopic", "experimental", element.getExperimentalElement(), -1);
20357    }
20358    if (element.hasDateElement()) {
20359      composeDateTime(t, "SubscriptionTopic", "date", element.getDateElement(), -1);
20360    }
20361    if (element.hasPublisherElement()) {
20362      composeString(t, "SubscriptionTopic", "publisher", element.getPublisherElement(), -1);
20363    }
20364    for (int i = 0; i < element.getContact().size(); i++) {
20365      composeContactDetail(t, "SubscriptionTopic", "contact", element.getContact().get(i), i);
20366    }
20367    if (element.hasDescriptionElement()) {
20368      composeMarkdown(t, "SubscriptionTopic", "description", element.getDescriptionElement(), -1);
20369    }
20370    for (int i = 0; i < element.getUseContext().size(); i++) {
20371      composeUsageContext(t, "SubscriptionTopic", "useContext", element.getUseContext().get(i), i);
20372    }
20373    for (int i = 0; i < element.getJurisdiction().size(); i++) {
20374      composeCodeableConcept(t, "SubscriptionTopic", "jurisdiction", element.getJurisdiction().get(i), i);
20375    }
20376    if (element.hasPurposeElement()) {
20377      composeMarkdown(t, "SubscriptionTopic", "purpose", element.getPurposeElement(), -1);
20378    }
20379    if (element.hasCopyrightElement()) {
20380      composeMarkdown(t, "SubscriptionTopic", "copyright", element.getCopyrightElement(), -1);
20381    }
20382    if (element.hasApprovalDateElement()) {
20383      composeDate(t, "SubscriptionTopic", "approvalDate", element.getApprovalDateElement(), -1);
20384    }
20385    if (element.hasLastReviewDateElement()) {
20386      composeDate(t, "SubscriptionTopic", "lastReviewDate", element.getLastReviewDateElement(), -1);
20387    }
20388    if (element.hasEffectivePeriod()) {
20389      composePeriod(t, "SubscriptionTopic", "effectivePeriod", element.getEffectivePeriod(), -1);
20390    }
20391    for (int i = 0; i < element.getResourceTrigger().size(); i++) {
20392      composeSubscriptionTopicResourceTriggerComponent(t, "SubscriptionTopic", "resourceTrigger", element.getResourceTrigger().get(i), i);
20393    }
20394    for (int i = 0; i < element.getEventTrigger().size(); i++) {
20395      composeSubscriptionTopicEventTriggerComponent(t, "SubscriptionTopic", "eventTrigger", element.getEventTrigger().get(i), i);
20396    }
20397    for (int i = 0; i < element.getCanFilterBy().size(); i++) {
20398      composeSubscriptionTopicCanFilterByComponent(t, "SubscriptionTopic", "canFilterBy", element.getCanFilterBy().get(i), i);
20399    }
20400    for (int i = 0; i < element.getNotificationShape().size(); i++) {
20401      composeSubscriptionTopicNotificationShapeComponent(t, "SubscriptionTopic", "notificationShape", element.getNotificationShape().get(i), i);
20402    }
20403  }
20404
20405  protected void composeSubscriptionTopicResourceTriggerComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicResourceTriggerComponent element, int index) {
20406    if (element == null) 
20407      return;
20408    Complex t;
20409    if (Utilities.noString(parentType))
20410      t = parent;
20411    else {
20412      t = parent.predicate("fhir:"+parentType+'.'+name);
20413    }
20414    composeBackboneElement(t, "resourceTrigger", name, element, index);
20415    if (element.hasDescriptionElement()) {
20416      composeMarkdown(t, "SubscriptionTopicResourceTriggerComponent", "description", element.getDescriptionElement(), -1);
20417    }
20418    if (element.hasResourceElement()) {
20419      composeUri(t, "SubscriptionTopicResourceTriggerComponent", "resource", element.getResourceElement(), -1);
20420    }
20421    for (int i = 0; i < element.getSupportedInteraction().size(); i++) {
20422      composeEnum(t, "SubscriptionTopicResourceTriggerComponent", "supportedInteraction", element.getSupportedInteraction().get(i), i);
20423    }
20424    if (element.hasQueryCriteria()) {
20425      composeSubscriptionTopicResourceTriggerQueryCriteriaComponent(t, "SubscriptionTopicResourceTriggerComponent", "queryCriteria", element.getQueryCriteria(), -1);
20426    }
20427    if (element.hasFhirPathCriteriaElement()) {
20428      composeString(t, "SubscriptionTopicResourceTriggerComponent", "fhirPathCriteria", element.getFhirPathCriteriaElement(), -1);
20429    }
20430  }
20431
20432  protected void composeSubscriptionTopicResourceTriggerQueryCriteriaComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicResourceTriggerQueryCriteriaComponent element, int index) {
20433    if (element == null) 
20434      return;
20435    Complex t;
20436    if (Utilities.noString(parentType))
20437      t = parent;
20438    else {
20439      t = parent.predicate("fhir:"+parentType+'.'+name);
20440    }
20441    composeBackboneElement(t, "queryCriteria", name, element, index);
20442    if (element.hasPreviousElement()) {
20443      composeString(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "previous", element.getPreviousElement(), -1);
20444    }
20445    if (element.hasResultForCreateElement()) {
20446      composeEnum(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "resultForCreate", element.getResultForCreateElement(), -1);
20447    }
20448    if (element.hasCurrentElement()) {
20449      composeString(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "current", element.getCurrentElement(), -1);
20450    }
20451    if (element.hasResultForDeleteElement()) {
20452      composeEnum(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "resultForDelete", element.getResultForDeleteElement(), -1);
20453    }
20454    if (element.hasRequireBothElement()) {
20455      composeBoolean(t, "SubscriptionTopicResourceTriggerQueryCriteriaComponent", "requireBoth", element.getRequireBothElement(), -1);
20456    }
20457  }
20458
20459  protected void composeSubscriptionTopicEventTriggerComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicEventTriggerComponent element, int index) {
20460    if (element == null) 
20461      return;
20462    Complex t;
20463    if (Utilities.noString(parentType))
20464      t = parent;
20465    else {
20466      t = parent.predicate("fhir:"+parentType+'.'+name);
20467    }
20468    composeBackboneElement(t, "eventTrigger", name, element, index);
20469    if (element.hasDescriptionElement()) {
20470      composeMarkdown(t, "SubscriptionTopicEventTriggerComponent", "description", element.getDescriptionElement(), -1);
20471    }
20472    if (element.hasEvent()) {
20473      composeCodeableConcept(t, "SubscriptionTopicEventTriggerComponent", "event", element.getEvent(), -1);
20474    }
20475    if (element.hasResourceElement()) {
20476      composeUri(t, "SubscriptionTopicEventTriggerComponent", "resource", element.getResourceElement(), -1);
20477    }
20478  }
20479
20480  protected void composeSubscriptionTopicCanFilterByComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicCanFilterByComponent element, int index) {
20481    if (element == null) 
20482      return;
20483    Complex t;
20484    if (Utilities.noString(parentType))
20485      t = parent;
20486    else {
20487      t = parent.predicate("fhir:"+parentType+'.'+name);
20488    }
20489    composeBackboneElement(t, "canFilterBy", name, element, index);
20490    if (element.hasDescriptionElement()) {
20491      composeMarkdown(t, "SubscriptionTopicCanFilterByComponent", "description", element.getDescriptionElement(), -1);
20492    }
20493    if (element.hasResourceElement()) {
20494      composeUri(t, "SubscriptionTopicCanFilterByComponent", "resource", element.getResourceElement(), -1);
20495    }
20496    if (element.hasFilterParameterElement()) {
20497      composeString(t, "SubscriptionTopicCanFilterByComponent", "filterParameter", element.getFilterParameterElement(), -1);
20498    }
20499    for (int i = 0; i < element.getModifier().size(); i++) {
20500      composeEnum(t, "SubscriptionTopicCanFilterByComponent", "modifier", element.getModifier().get(i), i);
20501    }
20502  }
20503
20504  protected void composeSubscriptionTopicNotificationShapeComponent(Complex parent, String parentType, String name, SubscriptionTopic.SubscriptionTopicNotificationShapeComponent element, int index) {
20505    if (element == null) 
20506      return;
20507    Complex t;
20508    if (Utilities.noString(parentType))
20509      t = parent;
20510    else {
20511      t = parent.predicate("fhir:"+parentType+'.'+name);
20512    }
20513    composeBackboneElement(t, "notificationShape", name, element, index);
20514    if (element.hasResourceElement()) {
20515      composeUri(t, "SubscriptionTopicNotificationShapeComponent", "resource", element.getResourceElement(), -1);
20516    }
20517    for (int i = 0; i < element.getInclude().size(); i++) {
20518      composeString(t, "SubscriptionTopicNotificationShapeComponent", "include", element.getInclude().get(i), i);
20519    }
20520    for (int i = 0; i < element.getRevInclude().size(); i++) {
20521      composeString(t, "SubscriptionTopicNotificationShapeComponent", "revInclude", element.getRevInclude().get(i), i);
20522    }
20523  }
20524
20525  protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) {
20526    if (element == null) 
20527      return;
20528    Complex t;
20529    if (Utilities.noString(parentType))
20530      t = parent;
20531    else {
20532      t = parent.predicate("fhir:"+parentType+'.'+name);
20533    }
20534    composeDomainResource(t, "Substance", name, element, index);
20535    for (int i = 0; i < element.getIdentifier().size(); i++) {
20536      composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i);
20537    }
20538    if (element.hasStatusElement()) {
20539      composeEnum(t, "Substance", "status", element.getStatusElement(), -1);
20540    }
20541    for (int i = 0; i < element.getCategory().size(); i++) {
20542      composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i);
20543    }
20544    if (element.hasCode()) {
20545      composeCodeableConcept(t, "Substance", "code", element.getCode(), -1);
20546    }
20547    if (element.hasDescriptionElement()) {
20548      composeString(t, "Substance", "description", element.getDescriptionElement(), -1);
20549    }
20550    for (int i = 0; i < element.getInstance().size(); i++) {
20551      composeSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i);
20552    }
20553    for (int i = 0; i < element.getIngredient().size(); i++) {
20554      composeSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i);
20555    }
20556  }
20557
20558  protected void composeSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) {
20559    if (element == null) 
20560      return;
20561    Complex t;
20562    if (Utilities.noString(parentType))
20563      t = parent;
20564    else {
20565      t = parent.predicate("fhir:"+parentType+'.'+name);
20566    }
20567    composeBackboneElement(t, "instance", name, element, index);
20568    if (element.hasIdentifier()) {
20569      composeIdentifier(t, "SubstanceInstanceComponent", "identifier", element.getIdentifier(), -1);
20570    }
20571    if (element.hasExpiryElement()) {
20572      composeDateTime(t, "SubstanceInstanceComponent", "expiry", element.getExpiryElement(), -1);
20573    }
20574    if (element.hasQuantity()) {
20575      composeQuantity(t, "SubstanceInstanceComponent", "quantity", element.getQuantity(), -1);
20576    }
20577  }
20578
20579  protected void composeSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) {
20580    if (element == null) 
20581      return;
20582    Complex t;
20583    if (Utilities.noString(parentType))
20584      t = parent;
20585    else {
20586      t = parent.predicate("fhir:"+parentType+'.'+name);
20587    }
20588    composeBackboneElement(t, "ingredient", name, element, index);
20589    if (element.hasQuantity()) {
20590      composeRatio(t, "SubstanceIngredientComponent", "quantity", element.getQuantity(), -1);
20591    }
20592    if (element.hasSubstance()) {
20593      composeType(t, "SubstanceIngredientComponent", "substance", element.getSubstance(), -1);
20594    }
20595  }
20596
20597  protected void composeSubstanceDefinition(Complex parent, String parentType, String name, SubstanceDefinition element, int index) {
20598    if (element == null) 
20599      return;
20600    Complex t;
20601    if (Utilities.noString(parentType))
20602      t = parent;
20603    else {
20604      t = parent.predicate("fhir:"+parentType+'.'+name);
20605    }
20606    composeDomainResource(t, "SubstanceDefinition", name, element, index);
20607    for (int i = 0; i < element.getIdentifier().size(); i++) {
20608      composeIdentifier(t, "SubstanceDefinition", "identifier", element.getIdentifier().get(i), i);
20609    }
20610    if (element.hasVersionElement()) {
20611      composeString(t, "SubstanceDefinition", "version", element.getVersionElement(), -1);
20612    }
20613    if (element.hasStatus()) {
20614      composeCodeableConcept(t, "SubstanceDefinition", "status", element.getStatus(), -1);
20615    }
20616    for (int i = 0; i < element.getClassification().size(); i++) {
20617      composeCodeableConcept(t, "SubstanceDefinition", "classification", element.getClassification().get(i), i);
20618    }
20619    if (element.hasDomain()) {
20620      composeCodeableConcept(t, "SubstanceDefinition", "domain", element.getDomain(), -1);
20621    }
20622    for (int i = 0; i < element.getGrade().size(); i++) {
20623      composeCodeableConcept(t, "SubstanceDefinition", "grade", element.getGrade().get(i), i);
20624    }
20625    if (element.hasDescriptionElement()) {
20626      composeMarkdown(t, "SubstanceDefinition", "description", element.getDescriptionElement(), -1);
20627    }
20628    for (int i = 0; i < element.getInformationSource().size(); i++) {
20629      composeReference(t, "SubstanceDefinition", "informationSource", element.getInformationSource().get(i), i);
20630    }
20631    for (int i = 0; i < element.getNote().size(); i++) {
20632      composeAnnotation(t, "SubstanceDefinition", "note", element.getNote().get(i), i);
20633    }
20634    for (int i = 0; i < element.getManufacturer().size(); i++) {
20635      composeReference(t, "SubstanceDefinition", "manufacturer", element.getManufacturer().get(i), i);
20636    }
20637    for (int i = 0; i < element.getSupplier().size(); i++) {
20638      composeReference(t, "SubstanceDefinition", "supplier", element.getSupplier().get(i), i);
20639    }
20640    for (int i = 0; i < element.getMoiety().size(); i++) {
20641      composeSubstanceDefinitionMoietyComponent(t, "SubstanceDefinition", "moiety", element.getMoiety().get(i), i);
20642    }
20643    for (int i = 0; i < element.getProperty().size(); i++) {
20644      composeSubstanceDefinitionPropertyComponent(t, "SubstanceDefinition", "property", element.getProperty().get(i), i);
20645    }
20646    for (int i = 0; i < element.getMolecularWeight().size(); i++) {
20647      composeSubstanceDefinitionMolecularWeightComponent(t, "SubstanceDefinition", "molecularWeight", element.getMolecularWeight().get(i), i);
20648    }
20649    if (element.hasStructure()) {
20650      composeSubstanceDefinitionStructureComponent(t, "SubstanceDefinition", "structure", element.getStructure(), -1);
20651    }
20652    for (int i = 0; i < element.getCode().size(); i++) {
20653      composeSubstanceDefinitionCodeComponent(t, "SubstanceDefinition", "code", element.getCode().get(i), i);
20654    }
20655    for (int i = 0; i < element.getName().size(); i++) {
20656      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinition", "name", element.getName().get(i), i);
20657    }
20658    for (int i = 0; i < element.getRelationship().size(); i++) {
20659      composeSubstanceDefinitionRelationshipComponent(t, "SubstanceDefinition", "relationship", element.getRelationship().get(i), i);
20660    }
20661    if (element.hasSourceMaterial()) {
20662      composeSubstanceDefinitionSourceMaterialComponent(t, "SubstanceDefinition", "sourceMaterial", element.getSourceMaterial(), -1);
20663    }
20664  }
20665
20666  protected void composeSubstanceDefinitionMoietyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMoietyComponent element, int index) {
20667    if (element == null) 
20668      return;
20669    Complex t;
20670    if (Utilities.noString(parentType))
20671      t = parent;
20672    else {
20673      t = parent.predicate("fhir:"+parentType+'.'+name);
20674    }
20675    composeBackboneElement(t, "moiety", name, element, index);
20676    if (element.hasRole()) {
20677      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "role", element.getRole(), -1);
20678    }
20679    if (element.hasIdentifier()) {
20680      composeIdentifier(t, "SubstanceDefinitionMoietyComponent", "identifier", element.getIdentifier(), -1);
20681    }
20682    if (element.hasNameElement()) {
20683      composeString(t, "SubstanceDefinitionMoietyComponent", "name", element.getNameElement(), -1);
20684    }
20685    if (element.hasStereochemistry()) {
20686      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "stereochemistry", element.getStereochemistry(), -1);
20687    }
20688    if (element.hasOpticalActivity()) {
20689      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "opticalActivity", element.getOpticalActivity(), -1);
20690    }
20691    if (element.hasMolecularFormulaElement()) {
20692      composeString(t, "SubstanceDefinitionMoietyComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
20693    }
20694    if (element.hasAmount()) {
20695      composeType(t, "SubstanceDefinitionMoietyComponent", "amount", element.getAmount(), -1);
20696    }
20697    if (element.hasAmountType()) {
20698      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "amountType", element.getAmountType(), -1);
20699    }
20700  }
20701
20702  protected void composeSubstanceDefinitionPropertyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionPropertyComponent element, int index) {
20703    if (element == null) 
20704      return;
20705    Complex t;
20706    if (Utilities.noString(parentType))
20707      t = parent;
20708    else {
20709      t = parent.predicate("fhir:"+parentType+'.'+name);
20710    }
20711    composeBackboneElement(t, "property", name, element, index);
20712    if (element.hasType()) {
20713      composeCodeableConcept(t, "SubstanceDefinitionPropertyComponent", "type", element.getType(), -1);
20714    }
20715    if (element.hasValue()) {
20716      composeType(t, "SubstanceDefinitionPropertyComponent", "value", element.getValue(), -1);
20717    }
20718  }
20719
20720  protected void composeSubstanceDefinitionMolecularWeightComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMolecularWeightComponent element, int index) {
20721    if (element == null) 
20722      return;
20723    Complex t;
20724    if (Utilities.noString(parentType))
20725      t = parent;
20726    else {
20727      t = parent.predicate("fhir:"+parentType+'.'+name);
20728    }
20729    composeBackboneElement(t, "molecularWeight", name, element, index);
20730    if (element.hasMethod()) {
20731      composeCodeableConcept(t, "SubstanceDefinitionMolecularWeightComponent", "method", element.getMethod(), -1);
20732    }
20733    if (element.hasType()) {
20734      composeCodeableConcept(t, "SubstanceDefinitionMolecularWeightComponent", "type", element.getType(), -1);
20735    }
20736    if (element.hasAmount()) {
20737      composeQuantity(t, "SubstanceDefinitionMolecularWeightComponent", "amount", element.getAmount(), -1);
20738    }
20739  }
20740
20741  protected void composeSubstanceDefinitionStructureComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureComponent element, int index) {
20742    if (element == null) 
20743      return;
20744    Complex t;
20745    if (Utilities.noString(parentType))
20746      t = parent;
20747    else {
20748      t = parent.predicate("fhir:"+parentType+'.'+name);
20749    }
20750    composeBackboneElement(t, "structure", name, element, index);
20751    if (element.hasStereochemistry()) {
20752      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "stereochemistry", element.getStereochemistry(), -1);
20753    }
20754    if (element.hasOpticalActivity()) {
20755      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "opticalActivity", element.getOpticalActivity(), -1);
20756    }
20757    if (element.hasMolecularFormulaElement()) {
20758      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
20759    }
20760    if (element.hasMolecularFormulaByMoietyElement()) {
20761      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormulaByMoiety", element.getMolecularFormulaByMoietyElement(), -1);
20762    }
20763    if (element.hasMolecularWeight()) {
20764      composeSubstanceDefinitionMolecularWeightComponent(t, "SubstanceDefinitionStructureComponent", "molecularWeight", element.getMolecularWeight(), -1);
20765    }
20766    for (int i = 0; i < element.getTechnique().size(); i++) {
20767      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "technique", element.getTechnique().get(i), i);
20768    }
20769    for (int i = 0; i < element.getSourceDocument().size(); i++) {
20770      composeReference(t, "SubstanceDefinitionStructureComponent", "sourceDocument", element.getSourceDocument().get(i), i);
20771    }
20772    for (int i = 0; i < element.getRepresentation().size(); i++) {
20773      composeSubstanceDefinitionStructureRepresentationComponent(t, "SubstanceDefinitionStructureComponent", "representation", element.getRepresentation().get(i), i);
20774    }
20775  }
20776
20777  protected void composeSubstanceDefinitionStructureRepresentationComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureRepresentationComponent element, int index) {
20778    if (element == null) 
20779      return;
20780    Complex t;
20781    if (Utilities.noString(parentType))
20782      t = parent;
20783    else {
20784      t = parent.predicate("fhir:"+parentType+'.'+name);
20785    }
20786    composeBackboneElement(t, "representation", name, element, index);
20787    if (element.hasType()) {
20788      composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "type", element.getType(), -1);
20789    }
20790    if (element.hasRepresentationElement()) {
20791      composeString(t, "SubstanceDefinitionStructureRepresentationComponent", "representation", element.getRepresentationElement(), -1);
20792    }
20793    if (element.hasFormat()) {
20794      composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "format", element.getFormat(), -1);
20795    }
20796    if (element.hasDocument()) {
20797      composeReference(t, "SubstanceDefinitionStructureRepresentationComponent", "document", element.getDocument(), -1);
20798    }
20799  }
20800
20801  protected void composeSubstanceDefinitionCodeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionCodeComponent element, int index) {
20802    if (element == null) 
20803      return;
20804    Complex t;
20805    if (Utilities.noString(parentType))
20806      t = parent;
20807    else {
20808      t = parent.predicate("fhir:"+parentType+'.'+name);
20809    }
20810    composeBackboneElement(t, "code", name, element, index);
20811    if (element.hasCode()) {
20812      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "code", element.getCode(), -1);
20813    }
20814    if (element.hasStatus()) {
20815      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "status", element.getStatus(), -1);
20816    }
20817    if (element.hasStatusDateElement()) {
20818      composeDateTime(t, "SubstanceDefinitionCodeComponent", "statusDate", element.getStatusDateElement(), -1);
20819    }
20820    for (int i = 0; i < element.getNote().size(); i++) {
20821      composeAnnotation(t, "SubstanceDefinitionCodeComponent", "note", element.getNote().get(i), i);
20822    }
20823    for (int i = 0; i < element.getSource().size(); i++) {
20824      composeReference(t, "SubstanceDefinitionCodeComponent", "source", element.getSource().get(i), i);
20825    }
20826  }
20827
20828  protected void composeSubstanceDefinitionNameComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameComponent element, int index) {
20829    if (element == null) 
20830      return;
20831    Complex t;
20832    if (Utilities.noString(parentType))
20833      t = parent;
20834    else {
20835      t = parent.predicate("fhir:"+parentType+'.'+name);
20836    }
20837    composeBackboneElement(t, "name", name, element, index);
20838    if (element.hasNameElement()) {
20839      composeString(t, "SubstanceDefinitionNameComponent", "name", element.getNameElement(), -1);
20840    }
20841    if (element.hasType()) {
20842      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "type", element.getType(), -1);
20843    }
20844    if (element.hasStatus()) {
20845      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "status", element.getStatus(), -1);
20846    }
20847    if (element.hasPreferredElement()) {
20848      composeBoolean(t, "SubstanceDefinitionNameComponent", "preferred", element.getPreferredElement(), -1);
20849    }
20850    for (int i = 0; i < element.getLanguage().size(); i++) {
20851      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "language", element.getLanguage().get(i), i);
20852    }
20853    for (int i = 0; i < element.getDomain().size(); i++) {
20854      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "domain", element.getDomain().get(i), i);
20855    }
20856    for (int i = 0; i < element.getJurisdiction().size(); i++) {
20857      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "jurisdiction", element.getJurisdiction().get(i), i);
20858    }
20859    for (int i = 0; i < element.getSynonym().size(); i++) {
20860      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "synonym", element.getSynonym().get(i), i);
20861    }
20862    for (int i = 0; i < element.getTranslation().size(); i++) {
20863      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "translation", element.getTranslation().get(i), i);
20864    }
20865    for (int i = 0; i < element.getOfficial().size(); i++) {
20866      composeSubstanceDefinitionNameOfficialComponent(t, "SubstanceDefinitionNameComponent", "official", element.getOfficial().get(i), i);
20867    }
20868    for (int i = 0; i < element.getSource().size(); i++) {
20869      composeReference(t, "SubstanceDefinitionNameComponent", "source", element.getSource().get(i), i);
20870    }
20871  }
20872
20873  protected void composeSubstanceDefinitionNameOfficialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameOfficialComponent element, int index) {
20874    if (element == null) 
20875      return;
20876    Complex t;
20877    if (Utilities.noString(parentType))
20878      t = parent;
20879    else {
20880      t = parent.predicate("fhir:"+parentType+'.'+name);
20881    }
20882    composeBackboneElement(t, "official", name, element, index);
20883    if (element.hasAuthority()) {
20884      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "authority", element.getAuthority(), -1);
20885    }
20886    if (element.hasStatus()) {
20887      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "status", element.getStatus(), -1);
20888    }
20889    if (element.hasDateElement()) {
20890      composeDateTime(t, "SubstanceDefinitionNameOfficialComponent", "date", element.getDateElement(), -1);
20891    }
20892  }
20893
20894  protected void composeSubstanceDefinitionRelationshipComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionRelationshipComponent element, int index) {
20895    if (element == null) 
20896      return;
20897    Complex t;
20898    if (Utilities.noString(parentType))
20899      t = parent;
20900    else {
20901      t = parent.predicate("fhir:"+parentType+'.'+name);
20902    }
20903    composeBackboneElement(t, "relationship", name, element, index);
20904    if (element.hasSubstanceDefinition()) {
20905      composeType(t, "SubstanceDefinitionRelationshipComponent", "substanceDefinition", element.getSubstanceDefinition(), -1);
20906    }
20907    if (element.hasType()) {
20908      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "type", element.getType(), -1);
20909    }
20910    if (element.hasIsDefiningElement()) {
20911      composeBoolean(t, "SubstanceDefinitionRelationshipComponent", "isDefining", element.getIsDefiningElement(), -1);
20912    }
20913    if (element.hasAmount()) {
20914      composeType(t, "SubstanceDefinitionRelationshipComponent", "amount", element.getAmount(), -1);
20915    }
20916    if (element.hasAmountRatioHighLimit()) {
20917      composeRatio(t, "SubstanceDefinitionRelationshipComponent", "amountRatioHighLimit", element.getAmountRatioHighLimit(), -1);
20918    }
20919    if (element.hasAmountType()) {
20920      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "amountType", element.getAmountType(), -1);
20921    }
20922    for (int i = 0; i < element.getSource().size(); i++) {
20923      composeReference(t, "SubstanceDefinitionRelationshipComponent", "source", element.getSource().get(i), i);
20924    }
20925  }
20926
20927  protected void composeSubstanceDefinitionSourceMaterialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionSourceMaterialComponent element, int index) {
20928    if (element == null) 
20929      return;
20930    Complex t;
20931    if (Utilities.noString(parentType))
20932      t = parent;
20933    else {
20934      t = parent.predicate("fhir:"+parentType+'.'+name);
20935    }
20936    composeBackboneElement(t, "sourceMaterial", name, element, index);
20937    if (element.hasType()) {
20938      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "type", element.getType(), -1);
20939    }
20940    if (element.hasGenus()) {
20941      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "genus", element.getGenus(), -1);
20942    }
20943    if (element.hasSpecies()) {
20944      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "species", element.getSpecies(), -1);
20945    }
20946    if (element.hasPart()) {
20947      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "part", element.getPart(), -1);
20948    }
20949    for (int i = 0; i < element.getCountryOfOrigin().size(); i++) {
20950      composeCodeableConcept(t, "SubstanceDefinitionSourceMaterialComponent", "countryOfOrigin", element.getCountryOfOrigin().get(i), i);
20951    }
20952  }
20953
20954  protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) {
20955    if (element == null) 
20956      return;
20957    Complex t;
20958    if (Utilities.noString(parentType))
20959      t = parent;
20960    else {
20961      t = parent.predicate("fhir:"+parentType+'.'+name);
20962    }
20963    composeDomainResource(t, "SupplyDelivery", name, element, index);
20964    for (int i = 0; i < element.getIdentifier().size(); i++) {
20965      composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier().get(i), i);
20966    }
20967    for (int i = 0; i < element.getBasedOn().size(); i++) {
20968      composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i);
20969    }
20970    for (int i = 0; i < element.getPartOf().size(); i++) {
20971      composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i);
20972    }
20973    if (element.hasStatusElement()) {
20974      composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1);
20975    }
20976    if (element.hasPatient()) {
20977      composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1);
20978    }
20979    if (element.hasType()) {
20980      composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1);
20981    }
20982    if (element.hasSuppliedItem()) {
20983      composeSupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1);
20984    }
20985    if (element.hasOccurrence()) {
20986      composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1);
20987    }
20988    if (element.hasSupplier()) {
20989      composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1);
20990    }
20991    if (element.hasDestination()) {
20992      composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1);
20993    }
20994    for (int i = 0; i < element.getReceiver().size(); i++) {
20995      composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i);
20996    }
20997  }
20998
20999  protected void composeSupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) {
21000    if (element == null) 
21001      return;
21002    Complex t;
21003    if (Utilities.noString(parentType))
21004      t = parent;
21005    else {
21006      t = parent.predicate("fhir:"+parentType+'.'+name);
21007    }
21008    composeBackboneElement(t, "suppliedItem", name, element, index);
21009    if (element.hasQuantity()) {
21010      composeQuantity(t, "SupplyDeliverySuppliedItemComponent", "quantity", element.getQuantity(), -1);
21011    }
21012    if (element.hasItem()) {
21013      composeType(t, "SupplyDeliverySuppliedItemComponent", "item", element.getItem(), -1);
21014    }
21015  }
21016
21017  protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) {
21018    if (element == null) 
21019      return;
21020    Complex t;
21021    if (Utilities.noString(parentType))
21022      t = parent;
21023    else {
21024      t = parent.predicate("fhir:"+parentType+'.'+name);
21025    }
21026    composeDomainResource(t, "SupplyRequest", name, element, index);
21027    for (int i = 0; i < element.getIdentifier().size(); i++) {
21028      composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier().get(i), i);
21029    }
21030    if (element.hasStatusElement()) {
21031      composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1);
21032    }
21033    if (element.hasCategory()) {
21034      composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1);
21035    }
21036    if (element.hasPriorityElement()) {
21037      composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1);
21038    }
21039    if (element.hasItem()) {
21040      composeType(t, "SupplyRequest", "item", element.getItem(), -1);
21041    }
21042    if (element.hasQuantity()) {
21043      composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1);
21044    }
21045    for (int i = 0; i < element.getParameter().size(); i++) {
21046      composeSupplyRequestParameterComponent(t, "SupplyRequest", "parameter", element.getParameter().get(i), i);
21047    }
21048    if (element.hasOccurrence()) {
21049      composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1);
21050    }
21051    if (element.hasAuthoredOnElement()) {
21052      composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1);
21053    }
21054    if (element.hasRequester()) {
21055      composeReference(t, "SupplyRequest", "requester", element.getRequester(), -1);
21056    }
21057    for (int i = 0; i < element.getSupplier().size(); i++) {
21058      composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i);
21059    }
21060    for (int i = 0; i < element.getReasonCode().size(); i++) {
21061      composeCodeableConcept(t, "SupplyRequest", "reasonCode", element.getReasonCode().get(i), i);
21062    }
21063    for (int i = 0; i < element.getReasonReference().size(); i++) {
21064      composeReference(t, "SupplyRequest", "reasonReference", element.getReasonReference().get(i), i);
21065    }
21066    if (element.hasDeliverFrom()) {
21067      composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1);
21068    }
21069    if (element.hasDeliverTo()) {
21070      composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1);
21071    }
21072  }
21073
21074  protected void composeSupplyRequestParameterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestParameterComponent element, int index) {
21075    if (element == null) 
21076      return;
21077    Complex t;
21078    if (Utilities.noString(parentType))
21079      t = parent;
21080    else {
21081      t = parent.predicate("fhir:"+parentType+'.'+name);
21082    }
21083    composeBackboneElement(t, "parameter", name, element, index);
21084    if (element.hasCode()) {
21085      composeCodeableConcept(t, "SupplyRequestParameterComponent", "code", element.getCode(), -1);
21086    }
21087    if (element.hasValue()) {
21088      composeType(t, "SupplyRequestParameterComponent", "value", element.getValue(), -1);
21089    }
21090  }
21091
21092  protected void composeTask(Complex parent, String parentType, String name, Task element, int index) {
21093    if (element == null) 
21094      return;
21095    Complex t;
21096    if (Utilities.noString(parentType))
21097      t = parent;
21098    else {
21099      t = parent.predicate("fhir:"+parentType+'.'+name);
21100    }
21101    composeDomainResource(t, "Task", name, element, index);
21102    for (int i = 0; i < element.getIdentifier().size(); i++) {
21103      composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i);
21104    }
21105    if (element.hasInstantiatesCanonicalElement()) {
21106      composeCanonical(t, "Task", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
21107    }
21108    if (element.hasInstantiatesUriElement()) {
21109      composeUri(t, "Task", "instantiatesUri", element.getInstantiatesUriElement(), -1);
21110    }
21111    for (int i = 0; i < element.getBasedOn().size(); i++) {
21112      composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i);
21113    }
21114    if (element.hasGroupIdentifier()) {
21115      composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1);
21116    }
21117    for (int i = 0; i < element.getPartOf().size(); i++) {
21118      composeReference(t, "Task", "partOf", element.getPartOf().get(i), i);
21119    }
21120    if (element.hasStatusElement()) {
21121      composeEnum(t, "Task", "status", element.getStatusElement(), -1);
21122    }
21123    if (element.hasStatusReason()) {
21124      composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1);
21125    }
21126    if (element.hasBusinessStatus()) {
21127      composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1);
21128    }
21129    if (element.hasIntentElement()) {
21130      composeEnum(t, "Task", "intent", element.getIntentElement(), -1);
21131    }
21132    if (element.hasPriorityElement()) {
21133      composeEnum(t, "Task", "priority", element.getPriorityElement(), -1);
21134    }
21135    if (element.hasCode()) {
21136      composeCodeableConcept(t, "Task", "code", element.getCode(), -1);
21137    }
21138    if (element.hasDescriptionElement()) {
21139      composeString(t, "Task", "description", element.getDescriptionElement(), -1);
21140    }
21141    if (element.hasFocus()) {
21142      composeReference(t, "Task", "focus", element.getFocus(), -1);
21143    }
21144    if (element.hasFor()) {
21145      composeReference(t, "Task", "for", element.getFor(), -1);
21146    }
21147    if (element.hasEncounter()) {
21148      composeReference(t, "Task", "encounter", element.getEncounter(), -1);
21149    }
21150    if (element.hasExecutionPeriod()) {
21151      composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1);
21152    }
21153    if (element.hasAuthoredOnElement()) {
21154      composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1);
21155    }
21156    if (element.hasLastModifiedElement()) {
21157      composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1);
21158    }
21159    if (element.hasRequester()) {
21160      composeReference(t, "Task", "requester", element.getRequester(), -1);
21161    }
21162    for (int i = 0; i < element.getPerformerType().size(); i++) {
21163      composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i);
21164    }
21165    if (element.hasOwner()) {
21166      composeReference(t, "Task", "owner", element.getOwner(), -1);
21167    }
21168    if (element.hasLocation()) {
21169      composeReference(t, "Task", "location", element.getLocation(), -1);
21170    }
21171    if (element.hasReasonCode()) {
21172      composeCodeableConcept(t, "Task", "reasonCode", element.getReasonCode(), -1);
21173    }
21174    if (element.hasReasonReference()) {
21175      composeReference(t, "Task", "reasonReference", element.getReasonReference(), -1);
21176    }
21177    for (int i = 0; i < element.getInsurance().size(); i++) {
21178      composeReference(t, "Task", "insurance", element.getInsurance().get(i), i);
21179    }
21180    for (int i = 0; i < element.getNote().size(); i++) {
21181      composeAnnotation(t, "Task", "note", element.getNote().get(i), i);
21182    }
21183    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
21184      composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i);
21185    }
21186    if (element.hasRestriction()) {
21187      composeTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1);
21188    }
21189    for (int i = 0; i < element.getInput().size(); i++) {
21190      composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i);
21191    }
21192    for (int i = 0; i < element.getOutput().size(); i++) {
21193      composeTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i);
21194    }
21195  }
21196
21197  protected void composeTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) {
21198    if (element == null) 
21199      return;
21200    Complex t;
21201    if (Utilities.noString(parentType))
21202      t = parent;
21203    else {
21204      t = parent.predicate("fhir:"+parentType+'.'+name);
21205    }
21206    composeBackboneElement(t, "restriction", name, element, index);
21207    if (element.hasRepetitionsElement()) {
21208      composePositiveInt(t, "TaskRestrictionComponent", "repetitions", element.getRepetitionsElement(), -1);
21209    }
21210    if (element.hasPeriod()) {
21211      composePeriod(t, "TaskRestrictionComponent", "period", element.getPeriod(), -1);
21212    }
21213    for (int i = 0; i < element.getRecipient().size(); i++) {
21214      composeReference(t, "TaskRestrictionComponent", "recipient", element.getRecipient().get(i), i);
21215    }
21216  }
21217
21218  protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) {
21219    if (element == null) 
21220      return;
21221    Complex t;
21222    if (Utilities.noString(parentType))
21223      t = parent;
21224    else {
21225      t = parent.predicate("fhir:"+parentType+'.'+name);
21226    }
21227    composeBackboneElement(t, "input", name, element, index);
21228    if (element.hasType()) {
21229      composeCodeableConcept(t, "ParameterComponent", "type", element.getType(), -1);
21230    }
21231    if (element.hasValue()) {
21232      composeType(t, "ParameterComponent", "value", element.getValue(), -1);
21233    }
21234  }
21235
21236  protected void composeTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) {
21237    if (element == null) 
21238      return;
21239    Complex t;
21240    if (Utilities.noString(parentType))
21241      t = parent;
21242    else {
21243      t = parent.predicate("fhir:"+parentType+'.'+name);
21244    }
21245    composeBackboneElement(t, "output", name, element, index);
21246    if (element.hasType()) {
21247      composeCodeableConcept(t, "TaskOutputComponent", "type", element.getType(), -1);
21248    }
21249    if (element.hasValue()) {
21250      composeType(t, "TaskOutputComponent", "value", element.getValue(), -1);
21251    }
21252  }
21253
21254  protected void composeTerminologyCapabilities(Complex parent, String parentType, String name, TerminologyCapabilities element, int index) {
21255    if (element == null) 
21256      return;
21257    Complex t;
21258    if (Utilities.noString(parentType))
21259      t = parent;
21260    else {
21261      t = parent.predicate("fhir:"+parentType+'.'+name);
21262    }
21263    composeDomainResource(t, "TerminologyCapabilities", name, element, index);
21264    if (element.hasUrlElement()) {
21265      composeUri(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1);
21266    }
21267    if (element.hasVersionElement()) {
21268      composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1);
21269    }
21270    if (element.hasNameElement()) {
21271      composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1);
21272    }
21273    if (element.hasTitleElement()) {
21274      composeString(t, "TerminologyCapabilities", "title", element.getTitleElement(), -1);
21275    }
21276    if (element.hasStatusElement()) {
21277      composeEnum(t, "TerminologyCapabilities", "status", element.getStatusElement(), -1);
21278    }
21279    if (element.hasExperimentalElement()) {
21280      composeBoolean(t, "TerminologyCapabilities", "experimental", element.getExperimentalElement(), -1);
21281    }
21282    if (element.hasDateElement()) {
21283      composeDateTime(t, "TerminologyCapabilities", "date", element.getDateElement(), -1);
21284    }
21285    if (element.hasPublisherElement()) {
21286      composeString(t, "TerminologyCapabilities", "publisher", element.getPublisherElement(), -1);
21287    }
21288    for (int i = 0; i < element.getContact().size(); i++) {
21289      composeContactDetail(t, "TerminologyCapabilities", "contact", element.getContact().get(i), i);
21290    }
21291    if (element.hasDescriptionElement()) {
21292      composeMarkdown(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1);
21293    }
21294    for (int i = 0; i < element.getUseContext().size(); i++) {
21295      composeUsageContext(t, "TerminologyCapabilities", "useContext", element.getUseContext().get(i), i);
21296    }
21297    for (int i = 0; i < element.getJurisdiction().size(); i++) {
21298      composeCodeableConcept(t, "TerminologyCapabilities", "jurisdiction", element.getJurisdiction().get(i), i);
21299    }
21300    if (element.hasPurposeElement()) {
21301      composeMarkdown(t, "TerminologyCapabilities", "purpose", element.getPurposeElement(), -1);
21302    }
21303    if (element.hasCopyrightElement()) {
21304      composeMarkdown(t, "TerminologyCapabilities", "copyright", element.getCopyrightElement(), -1);
21305    }
21306    if (element.hasKindElement()) {
21307      composeEnum(t, "TerminologyCapabilities", "kind", element.getKindElement(), -1);
21308    }
21309    if (element.hasSoftware()) {
21310      composeTerminologyCapabilitiesSoftwareComponent(t, "TerminologyCapabilities", "software", element.getSoftware(), -1);
21311    }
21312    if (element.hasImplementation()) {
21313      composeTerminologyCapabilitiesImplementationComponent(t, "TerminologyCapabilities", "implementation", element.getImplementation(), -1);
21314    }
21315    if (element.hasLockedDateElement()) {
21316      composeBoolean(t, "TerminologyCapabilities", "lockedDate", element.getLockedDateElement(), -1);
21317    }
21318    for (int i = 0; i < element.getCodeSystem().size(); i++) {
21319      composeTerminologyCapabilitiesCodeSystemComponent(t, "TerminologyCapabilities", "codeSystem", element.getCodeSystem().get(i), i);
21320    }
21321    if (element.hasExpansion()) {
21322      composeTerminologyCapabilitiesExpansionComponent(t, "TerminologyCapabilities", "expansion", element.getExpansion(), -1);
21323    }
21324    if (element.hasCodeSearchElement()) {
21325      composeEnum(t, "TerminologyCapabilities", "codeSearch", element.getCodeSearchElement(), -1);
21326    }
21327    if (element.hasValidateCode()) {
21328      composeTerminologyCapabilitiesValidateCodeComponent(t, "TerminologyCapabilities", "validateCode", element.getValidateCode(), -1);
21329    }
21330    if (element.hasTranslation()) {
21331      composeTerminologyCapabilitiesTranslationComponent(t, "TerminologyCapabilities", "translation", element.getTranslation(), -1);
21332    }
21333    if (element.hasClosure()) {
21334      composeTerminologyCapabilitiesClosureComponent(t, "TerminologyCapabilities", "closure", element.getClosure(), -1);
21335    }
21336  }
21337
21338  protected void composeTerminologyCapabilitiesSoftwareComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesSoftwareComponent element, int index) {
21339    if (element == null) 
21340      return;
21341    Complex t;
21342    if (Utilities.noString(parentType))
21343      t = parent;
21344    else {
21345      t = parent.predicate("fhir:"+parentType+'.'+name);
21346    }
21347    composeBackboneElement(t, "software", name, element, index);
21348    if (element.hasNameElement()) {
21349      composeString(t, "TerminologyCapabilitiesSoftwareComponent", "name", element.getNameElement(), -1);
21350    }
21351    if (element.hasVersionElement()) {
21352      composeString(t, "TerminologyCapabilitiesSoftwareComponent", "version", element.getVersionElement(), -1);
21353    }
21354  }
21355
21356  protected void composeTerminologyCapabilitiesImplementationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesImplementationComponent element, int index) {
21357    if (element == null) 
21358      return;
21359    Complex t;
21360    if (Utilities.noString(parentType))
21361      t = parent;
21362    else {
21363      t = parent.predicate("fhir:"+parentType+'.'+name);
21364    }
21365    composeBackboneElement(t, "implementation", name, element, index);
21366    if (element.hasDescriptionElement()) {
21367      composeString(t, "TerminologyCapabilitiesImplementationComponent", "description", element.getDescriptionElement(), -1);
21368    }
21369    if (element.hasUrlElement()) {
21370      composeUrl(t, "TerminologyCapabilitiesImplementationComponent", "url", element.getUrlElement(), -1);
21371    }
21372  }
21373
21374  protected void composeTerminologyCapabilitiesCodeSystemComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemComponent element, int index) {
21375    if (element == null) 
21376      return;
21377    Complex t;
21378    if (Utilities.noString(parentType))
21379      t = parent;
21380    else {
21381      t = parent.predicate("fhir:"+parentType+'.'+name);
21382    }
21383    composeBackboneElement(t, "codeSystem", name, element, index);
21384    if (element.hasUriElement()) {
21385      composeCanonical(t, "TerminologyCapabilitiesCodeSystemComponent", "uri", element.getUriElement(), -1);
21386    }
21387    for (int i = 0; i < element.getVersion().size(); i++) {
21388      composeTerminologyCapabilitiesCodeSystemVersionComponent(t, "TerminologyCapabilitiesCodeSystemComponent", "version", element.getVersion().get(i), i);
21389    }
21390    if (element.hasSubsumptionElement()) {
21391      composeBoolean(t, "TerminologyCapabilitiesCodeSystemComponent", "subsumption", element.getSubsumptionElement(), -1);
21392    }
21393  }
21394
21395  protected void composeTerminologyCapabilitiesCodeSystemVersionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionComponent element, int index) {
21396    if (element == null) 
21397      return;
21398    Complex t;
21399    if (Utilities.noString(parentType))
21400      t = parent;
21401    else {
21402      t = parent.predicate("fhir:"+parentType+'.'+name);
21403    }
21404    composeBackboneElement(t, "version", name, element, index);
21405    if (element.hasCodeElement()) {
21406      composeString(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "code", element.getCodeElement(), -1);
21407    }
21408    if (element.hasIsDefaultElement()) {
21409      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "isDefault", element.getIsDefaultElement(), -1);
21410    }
21411    if (element.hasCompositionalElement()) {
21412      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "compositional", element.getCompositionalElement(), -1);
21413    }
21414    for (int i = 0; i < element.getLanguage().size(); i++) {
21415      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "language", element.getLanguage().get(i), i);
21416    }
21417    for (int i = 0; i < element.getFilter().size(); i++) {
21418      composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "filter", element.getFilter().get(i), i);
21419    }
21420    for (int i = 0; i < element.getProperty().size(); i++) {
21421      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "property", element.getProperty().get(i), i);
21422    }
21423  }
21424
21425  protected void composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionFilterComponent element, int index) {
21426    if (element == null) 
21427      return;
21428    Complex t;
21429    if (Utilities.noString(parentType))
21430      t = parent;
21431    else {
21432      t = parent.predicate("fhir:"+parentType+'.'+name);
21433    }
21434    composeBackboneElement(t, "filter", name, element, index);
21435    if (element.hasCodeElement()) {
21436      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "code", element.getCodeElement(), -1);
21437    }
21438    for (int i = 0; i < element.getOp().size(); i++) {
21439      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "op", element.getOp().get(i), i);
21440    }
21441  }
21442
21443  protected void composeTerminologyCapabilitiesExpansionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionComponent element, int index) {
21444    if (element == null) 
21445      return;
21446    Complex t;
21447    if (Utilities.noString(parentType))
21448      t = parent;
21449    else {
21450      t = parent.predicate("fhir:"+parentType+'.'+name);
21451    }
21452    composeBackboneElement(t, "expansion", name, element, index);
21453    if (element.hasHierarchicalElement()) {
21454      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "hierarchical", element.getHierarchicalElement(), -1);
21455    }
21456    if (element.hasPagingElement()) {
21457      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "paging", element.getPagingElement(), -1);
21458    }
21459    if (element.hasIncompleteElement()) {
21460      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "incomplete", element.getIncompleteElement(), -1);
21461    }
21462    for (int i = 0; i < element.getParameter().size(); i++) {
21463      composeTerminologyCapabilitiesExpansionParameterComponent(t, "TerminologyCapabilitiesExpansionComponent", "parameter", element.getParameter().get(i), i);
21464    }
21465    if (element.hasTextFilterElement()) {
21466      composeMarkdown(t, "TerminologyCapabilitiesExpansionComponent", "textFilter", element.getTextFilterElement(), -1);
21467    }
21468  }
21469
21470  protected void composeTerminologyCapabilitiesExpansionParameterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionParameterComponent element, int index) {
21471    if (element == null) 
21472      return;
21473    Complex t;
21474    if (Utilities.noString(parentType))
21475      t = parent;
21476    else {
21477      t = parent.predicate("fhir:"+parentType+'.'+name);
21478    }
21479    composeBackboneElement(t, "parameter", name, element, index);
21480    if (element.hasNameElement()) {
21481      composeCode(t, "TerminologyCapabilitiesExpansionParameterComponent", "name", element.getNameElement(), -1);
21482    }
21483    if (element.hasDocumentationElement()) {
21484      composeString(t, "TerminologyCapabilitiesExpansionParameterComponent", "documentation", element.getDocumentationElement(), -1);
21485    }
21486  }
21487
21488  protected void composeTerminologyCapabilitiesValidateCodeComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesValidateCodeComponent element, int index) {
21489    if (element == null) 
21490      return;
21491    Complex t;
21492    if (Utilities.noString(parentType))
21493      t = parent;
21494    else {
21495      t = parent.predicate("fhir:"+parentType+'.'+name);
21496    }
21497    composeBackboneElement(t, "validateCode", name, element, index);
21498    if (element.hasTranslationsElement()) {
21499      composeBoolean(t, "TerminologyCapabilitiesValidateCodeComponent", "translations", element.getTranslationsElement(), -1);
21500    }
21501  }
21502
21503  protected void composeTerminologyCapabilitiesTranslationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesTranslationComponent element, int index) {
21504    if (element == null) 
21505      return;
21506    Complex t;
21507    if (Utilities.noString(parentType))
21508      t = parent;
21509    else {
21510      t = parent.predicate("fhir:"+parentType+'.'+name);
21511    }
21512    composeBackboneElement(t, "translation", name, element, index);
21513    if (element.hasNeedsMapElement()) {
21514      composeBoolean(t, "TerminologyCapabilitiesTranslationComponent", "needsMap", element.getNeedsMapElement(), -1);
21515    }
21516  }
21517
21518  protected void composeTerminologyCapabilitiesClosureComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesClosureComponent element, int index) {
21519    if (element == null) 
21520      return;
21521    Complex t;
21522    if (Utilities.noString(parentType))
21523      t = parent;
21524    else {
21525      t = parent.predicate("fhir:"+parentType+'.'+name);
21526    }
21527    composeBackboneElement(t, "closure", name, element, index);
21528    if (element.hasTranslationElement()) {
21529      composeBoolean(t, "TerminologyCapabilitiesClosureComponent", "translation", element.getTranslationElement(), -1);
21530    }
21531  }
21532
21533  protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) {
21534    if (element == null) 
21535      return;
21536    Complex t;
21537    if (Utilities.noString(parentType))
21538      t = parent;
21539    else {
21540      t = parent.predicate("fhir:"+parentType+'.'+name);
21541    }
21542    composeDomainResource(t, "TestReport", name, element, index);
21543    if (element.hasIdentifier()) {
21544      composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1);
21545    }
21546    if (element.hasNameElement()) {
21547      composeString(t, "TestReport", "name", element.getNameElement(), -1);
21548    }
21549    if (element.hasStatusElement()) {
21550      composeEnum(t, "TestReport", "status", element.getStatusElement(), -1);
21551    }
21552    if (element.hasTestScript()) {
21553      composeReference(t, "TestReport", "testScript", element.getTestScript(), -1);
21554    }
21555    if (element.hasResultElement()) {
21556      composeEnum(t, "TestReport", "result", element.getResultElement(), -1);
21557    }
21558    if (element.hasScoreElement()) {
21559      composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1);
21560    }
21561    if (element.hasTesterElement()) {
21562      composeString(t, "TestReport", "tester", element.getTesterElement(), -1);
21563    }
21564    if (element.hasIssuedElement()) {
21565      composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1);
21566    }
21567    for (int i = 0; i < element.getParticipant().size(); i++) {
21568      composeTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i);
21569    }
21570    if (element.hasSetup()) {
21571      composeTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1);
21572    }
21573    for (int i = 0; i < element.getTest().size(); i++) {
21574      composeTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i);
21575    }
21576    if (element.hasTeardown()) {
21577      composeTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1);
21578    }
21579  }
21580
21581  protected void composeTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) {
21582    if (element == null) 
21583      return;
21584    Complex t;
21585    if (Utilities.noString(parentType))
21586      t = parent;
21587    else {
21588      t = parent.predicate("fhir:"+parentType+'.'+name);
21589    }
21590    composeBackboneElement(t, "participant", name, element, index);
21591    if (element.hasTypeElement()) {
21592      composeEnum(t, "TestReportParticipantComponent", "type", element.getTypeElement(), -1);
21593    }
21594    if (element.hasUriElement()) {
21595      composeUri(t, "TestReportParticipantComponent", "uri", element.getUriElement(), -1);
21596    }
21597    if (element.hasDisplayElement()) {
21598      composeString(t, "TestReportParticipantComponent", "display", element.getDisplayElement(), -1);
21599    }
21600  }
21601
21602  protected void composeTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent element, int index) {
21603    if (element == null) 
21604      return;
21605    Complex t;
21606    if (Utilities.noString(parentType))
21607      t = parent;
21608    else {
21609      t = parent.predicate("fhir:"+parentType+'.'+name);
21610    }
21611    composeBackboneElement(t, "setup", name, element, index);
21612    for (int i = 0; i < element.getAction().size(); i++) {
21613      composeTestReportSetupActionComponent(t, "TestReportSetupComponent", "action", element.getAction().get(i), i);
21614    }
21615  }
21616
21617  protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent element, int index) {
21618    if (element == null) 
21619      return;
21620    Complex t;
21621    if (Utilities.noString(parentType))
21622      t = parent;
21623    else {
21624      t = parent.predicate("fhir:"+parentType+'.'+name);
21625    }
21626    composeBackboneElement(t, "action", name, element, index);
21627    if (element.hasOperation()) {
21628      composeTestReportSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1);
21629    }
21630    if (element.hasAssert()) {
21631      composeTestReportSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
21632    }
21633  }
21634
21635  protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) {
21636    if (element == null) 
21637      return;
21638    Complex t;
21639    if (Utilities.noString(parentType))
21640      t = parent;
21641    else {
21642      t = parent.predicate("fhir:"+parentType+'.'+name);
21643    }
21644    composeBackboneElement(t, "operation", name, element, index);
21645    if (element.hasResultElement()) {
21646      composeEnum(t, "SetupActionOperationComponent", "result", element.getResultElement(), -1);
21647    }
21648    if (element.hasMessageElement()) {
21649      composeMarkdown(t, "SetupActionOperationComponent", "message", element.getMessageElement(), -1);
21650    }
21651    if (element.hasDetailElement()) {
21652      composeUri(t, "SetupActionOperationComponent", "detail", element.getDetailElement(), -1);
21653    }
21654  }
21655
21656  protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) {
21657    if (element == null) 
21658      return;
21659    Complex t;
21660    if (Utilities.noString(parentType))
21661      t = parent;
21662    else {
21663      t = parent.predicate("fhir:"+parentType+'.'+name);
21664    }
21665    composeBackboneElement(t, "assert", name, element, index);
21666    if (element.hasResultElement()) {
21667      composeEnum(t, "SetupActionAssertComponent", "result", element.getResultElement(), -1);
21668    }
21669    if (element.hasMessageElement()) {
21670      composeMarkdown(t, "SetupActionAssertComponent", "message", element.getMessageElement(), -1);
21671    }
21672    if (element.hasDetailElement()) {
21673      composeString(t, "SetupActionAssertComponent", "detail", element.getDetailElement(), -1);
21674    }
21675  }
21676
21677  protected void composeTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) {
21678    if (element == null) 
21679      return;
21680    Complex t;
21681    if (Utilities.noString(parentType))
21682      t = parent;
21683    else {
21684      t = parent.predicate("fhir:"+parentType+'.'+name);
21685    }
21686    composeBackboneElement(t, "test", name, element, index);
21687    if (element.hasNameElement()) {
21688      composeString(t, "TestReportTestComponent", "name", element.getNameElement(), -1);
21689    }
21690    if (element.hasDescriptionElement()) {
21691      composeString(t, "TestReportTestComponent", "description", element.getDescriptionElement(), -1);
21692    }
21693    for (int i = 0; i < element.getAction().size(); i++) {
21694      composeTestReportTestActionComponent(t, "TestReportTestComponent", "action", element.getAction().get(i), i);
21695    }
21696  }
21697
21698  protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) {
21699    if (element == null) 
21700      return;
21701    Complex t;
21702    if (Utilities.noString(parentType))
21703      t = parent;
21704    else {
21705      t = parent.predicate("fhir:"+parentType+'.'+name);
21706    }
21707    composeBackboneElement(t, "action", name, element, index);
21708    if (element.hasOperation()) {
21709      composeTestReportSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
21710    }
21711    if (element.hasAssert()) {
21712      composeTestReportSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
21713    }
21714  }
21715
21716  protected void composeTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent element, int index) {
21717    if (element == null) 
21718      return;
21719    Complex t;
21720    if (Utilities.noString(parentType))
21721      t = parent;
21722    else {
21723      t = parent.predicate("fhir:"+parentType+'.'+name);
21724    }
21725    composeBackboneElement(t, "teardown", name, element, index);
21726    for (int i = 0; i < element.getAction().size(); i++) {
21727      composeTestReportTeardownActionComponent(t, "TestReportTeardownComponent", "action", element.getAction().get(i), i);
21728    }
21729  }
21730
21731  protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) {
21732    if (element == null) 
21733      return;
21734    Complex t;
21735    if (Utilities.noString(parentType))
21736      t = parent;
21737    else {
21738      t = parent.predicate("fhir:"+parentType+'.'+name);
21739    }
21740    composeBackboneElement(t, "action", name, element, index);
21741    if (element.hasOperation()) {
21742      composeTestReportSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
21743    }
21744  }
21745
21746  protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) {
21747    if (element == null) 
21748      return;
21749    Complex t;
21750    if (Utilities.noString(parentType))
21751      t = parent;
21752    else {
21753      t = parent.predicate("fhir:"+parentType+'.'+name);
21754    }
21755    composeDomainResource(t, "TestScript", name, element, index);
21756    if (element.hasUrlElement()) {
21757      composeUri(t, "TestScript", "url", element.getUrlElement(), -1);
21758    }
21759    if (element.hasIdentifier()) {
21760      composeIdentifier(t, "TestScript", "identifier", element.getIdentifier(), -1);
21761    }
21762    if (element.hasVersionElement()) {
21763      composeString(t, "TestScript", "version", element.getVersionElement(), -1);
21764    }
21765    if (element.hasNameElement()) {
21766      composeString(t, "TestScript", "name", element.getNameElement(), -1);
21767    }
21768    if (element.hasTitleElement()) {
21769      composeString(t, "TestScript", "title", element.getTitleElement(), -1);
21770    }
21771    if (element.hasStatusElement()) {
21772      composeEnum(t, "TestScript", "status", element.getStatusElement(), -1);
21773    }
21774    if (element.hasExperimentalElement()) {
21775      composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1);
21776    }
21777    if (element.hasDateElement()) {
21778      composeDateTime(t, "TestScript", "date", element.getDateElement(), -1);
21779    }
21780    if (element.hasPublisherElement()) {
21781      composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1);
21782    }
21783    for (int i = 0; i < element.getContact().size(); i++) {
21784      composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i);
21785    }
21786    if (element.hasDescriptionElement()) {
21787      composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1);
21788    }
21789    for (int i = 0; i < element.getUseContext().size(); i++) {
21790      composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i);
21791    }
21792    for (int i = 0; i < element.getJurisdiction().size(); i++) {
21793      composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i);
21794    }
21795    if (element.hasPurposeElement()) {
21796      composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1);
21797    }
21798    if (element.hasCopyrightElement()) {
21799      composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1);
21800    }
21801    for (int i = 0; i < element.getOrigin().size(); i++) {
21802      composeTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i);
21803    }
21804    for (int i = 0; i < element.getDestination().size(); i++) {
21805      composeTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i);
21806    }
21807    if (element.hasMetadata()) {
21808      composeTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1);
21809    }
21810    for (int i = 0; i < element.getFixture().size(); i++) {
21811      composeTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i);
21812    }
21813    for (int i = 0; i < element.getProfile().size(); i++) {
21814      composeReference(t, "TestScript", "profile", element.getProfile().get(i), i);
21815    }
21816    for (int i = 0; i < element.getVariable().size(); i++) {
21817      composeTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i);
21818    }
21819    if (element.hasSetup()) {
21820      composeTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1);
21821    }
21822    for (int i = 0; i < element.getTest().size(); i++) {
21823      composeTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i);
21824    }
21825    if (element.hasTeardown()) {
21826      composeTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1);
21827    }
21828  }
21829
21830  protected void composeTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) {
21831    if (element == null) 
21832      return;
21833    Complex t;
21834    if (Utilities.noString(parentType))
21835      t = parent;
21836    else {
21837      t = parent.predicate("fhir:"+parentType+'.'+name);
21838    }
21839    composeBackboneElement(t, "origin", name, element, index);
21840    if (element.hasIndexElement()) {
21841      composeInteger(t, "TestScriptOriginComponent", "index", element.getIndexElement(), -1);
21842    }
21843    if (element.hasProfile()) {
21844      composeCoding(t, "TestScriptOriginComponent", "profile", element.getProfile(), -1);
21845    }
21846  }
21847
21848  protected void composeTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) {
21849    if (element == null) 
21850      return;
21851    Complex t;
21852    if (Utilities.noString(parentType))
21853      t = parent;
21854    else {
21855      t = parent.predicate("fhir:"+parentType+'.'+name);
21856    }
21857    composeBackboneElement(t, "destination", name, element, index);
21858    if (element.hasIndexElement()) {
21859      composeInteger(t, "TestScriptDestinationComponent", "index", element.getIndexElement(), -1);
21860    }
21861    if (element.hasProfile()) {
21862      composeCoding(t, "TestScriptDestinationComponent", "profile", element.getProfile(), -1);
21863    }
21864  }
21865
21866  protected void composeTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) {
21867    if (element == null) 
21868      return;
21869    Complex t;
21870    if (Utilities.noString(parentType))
21871      t = parent;
21872    else {
21873      t = parent.predicate("fhir:"+parentType+'.'+name);
21874    }
21875    composeBackboneElement(t, "metadata", name, element, index);
21876    for (int i = 0; i < element.getLink().size(); i++) {
21877      composeTestScriptMetadataLinkComponent(t, "TestScriptMetadataComponent", "link", element.getLink().get(i), i);
21878    }
21879    for (int i = 0; i < element.getCapability().size(); i++) {
21880      composeTestScriptMetadataCapabilityComponent(t, "TestScriptMetadataComponent", "capability", element.getCapability().get(i), i);
21881    }
21882  }
21883
21884  protected void composeTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) {
21885    if (element == null) 
21886      return;
21887    Complex t;
21888    if (Utilities.noString(parentType))
21889      t = parent;
21890    else {
21891      t = parent.predicate("fhir:"+parentType+'.'+name);
21892    }
21893    composeBackboneElement(t, "link", name, element, index);
21894    if (element.hasUrlElement()) {
21895      composeUri(t, "TestScriptMetadataLinkComponent", "url", element.getUrlElement(), -1);
21896    }
21897    if (element.hasDescriptionElement()) {
21898      composeString(t, "TestScriptMetadataLinkComponent", "description", element.getDescriptionElement(), -1);
21899    }
21900  }
21901
21902  protected void composeTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) {
21903    if (element == null) 
21904      return;
21905    Complex t;
21906    if (Utilities.noString(parentType))
21907      t = parent;
21908    else {
21909      t = parent.predicate("fhir:"+parentType+'.'+name);
21910    }
21911    composeBackboneElement(t, "capability", name, element, index);
21912    if (element.hasRequiredElement()) {
21913      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "required", element.getRequiredElement(), -1);
21914    }
21915    if (element.hasValidatedElement()) {
21916      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "validated", element.getValidatedElement(), -1);
21917    }
21918    if (element.hasDescriptionElement()) {
21919      composeString(t, "TestScriptMetadataCapabilityComponent", "description", element.getDescriptionElement(), -1);
21920    }
21921    for (int i = 0; i < element.getOrigin().size(); i++) {
21922      composeInteger(t, "TestScriptMetadataCapabilityComponent", "origin", element.getOrigin().get(i), i);
21923    }
21924    if (element.hasDestinationElement()) {
21925      composeInteger(t, "TestScriptMetadataCapabilityComponent", "destination", element.getDestinationElement(), -1);
21926    }
21927    for (int i = 0; i < element.getLink().size(); i++) {
21928      composeUri(t, "TestScriptMetadataCapabilityComponent", "link", element.getLink().get(i), i);
21929    }
21930    if (element.hasCapabilitiesElement()) {
21931      composeCanonical(t, "TestScriptMetadataCapabilityComponent", "capabilities", element.getCapabilitiesElement(), -1);
21932    }
21933  }
21934
21935  protected void composeTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) {
21936    if (element == null) 
21937      return;
21938    Complex t;
21939    if (Utilities.noString(parentType))
21940      t = parent;
21941    else {
21942      t = parent.predicate("fhir:"+parentType+'.'+name);
21943    }
21944    composeBackboneElement(t, "fixture", name, element, index);
21945    if (element.hasAutocreateElement()) {
21946      composeBoolean(t, "TestScriptFixtureComponent", "autocreate", element.getAutocreateElement(), -1);
21947    }
21948    if (element.hasAutodeleteElement()) {
21949      composeBoolean(t, "TestScriptFixtureComponent", "autodelete", element.getAutodeleteElement(), -1);
21950    }
21951    if (element.hasResource()) {
21952      composeReference(t, "TestScriptFixtureComponent", "resource", element.getResource(), -1);
21953    }
21954  }
21955
21956  protected void composeTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) {
21957    if (element == null) 
21958      return;
21959    Complex t;
21960    if (Utilities.noString(parentType))
21961      t = parent;
21962    else {
21963      t = parent.predicate("fhir:"+parentType+'.'+name);
21964    }
21965    composeBackboneElement(t, "variable", name, element, index);
21966    if (element.hasNameElement()) {
21967      composeString(t, "TestScriptVariableComponent", "name", element.getNameElement(), -1);
21968    }
21969    if (element.hasDefaultValueElement()) {
21970      composeString(t, "TestScriptVariableComponent", "defaultValue", element.getDefaultValueElement(), -1);
21971    }
21972    if (element.hasDescriptionElement()) {
21973      composeString(t, "TestScriptVariableComponent", "description", element.getDescriptionElement(), -1);
21974    }
21975    if (element.hasExpressionElement()) {
21976      composeString(t, "TestScriptVariableComponent", "expression", element.getExpressionElement(), -1);
21977    }
21978    if (element.hasHeaderFieldElement()) {
21979      composeString(t, "TestScriptVariableComponent", "headerField", element.getHeaderFieldElement(), -1);
21980    }
21981    if (element.hasHintElement()) {
21982      composeString(t, "TestScriptVariableComponent", "hint", element.getHintElement(), -1);
21983    }
21984    if (element.hasPathElement()) {
21985      composeString(t, "TestScriptVariableComponent", "path", element.getPathElement(), -1);
21986    }
21987    if (element.hasSourceIdElement()) {
21988      composeId(t, "TestScriptVariableComponent", "sourceId", element.getSourceIdElement(), -1);
21989    }
21990  }
21991
21992  protected void composeTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) {
21993    if (element == null) 
21994      return;
21995    Complex t;
21996    if (Utilities.noString(parentType))
21997      t = parent;
21998    else {
21999      t = parent.predicate("fhir:"+parentType+'.'+name);
22000    }
22001    composeBackboneElement(t, "setup", name, element, index);
22002    for (int i = 0; i < element.getAction().size(); i++) {
22003      composeTestScriptSetupActionComponent(t, "TestScriptSetupComponent", "action", element.getAction().get(i), i);
22004    }
22005  }
22006
22007  protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) {
22008    if (element == null) 
22009      return;
22010    Complex t;
22011    if (Utilities.noString(parentType))
22012      t = parent;
22013    else {
22014      t = parent.predicate("fhir:"+parentType+'.'+name);
22015    }
22016    composeBackboneElement(t, "action", name, element, index);
22017    if (element.hasOperation()) {
22018      composeTestScriptSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1);
22019    }
22020    if (element.hasAssert()) {
22021      composeTestScriptSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
22022    }
22023  }
22024
22025  protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) {
22026    if (element == null) 
22027      return;
22028    Complex t;
22029    if (Utilities.noString(parentType))
22030      t = parent;
22031    else {
22032      t = parent.predicate("fhir:"+parentType+'.'+name);
22033    }
22034    composeBackboneElement(t, "operation", name, element, index);
22035    if (element.hasType()) {
22036      composeCoding(t, "SetupActionOperationComponent", "type", element.getType(), -1);
22037    }
22038    if (element.hasResourceElement()) {
22039      composeEnum(t, "SetupActionOperationComponent", "resource", element.getResourceElement(), -1);
22040    }
22041    if (element.hasLabelElement()) {
22042      composeString(t, "SetupActionOperationComponent", "label", element.getLabelElement(), -1);
22043    }
22044    if (element.hasDescriptionElement()) {
22045      composeString(t, "SetupActionOperationComponent", "description", element.getDescriptionElement(), -1);
22046    }
22047    if (element.hasAcceptElement()) {
22048      composeCode(t, "SetupActionOperationComponent", "accept", element.getAcceptElement(), -1);
22049    }
22050    if (element.hasContentTypeElement()) {
22051      composeCode(t, "SetupActionOperationComponent", "contentType", element.getContentTypeElement(), -1);
22052    }
22053    if (element.hasDestinationElement()) {
22054      composeInteger(t, "SetupActionOperationComponent", "destination", element.getDestinationElement(), -1);
22055    }
22056    if (element.hasEncodeRequestUrlElement()) {
22057      composeBoolean(t, "SetupActionOperationComponent", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1);
22058    }
22059    if (element.hasMethodElement()) {
22060      composeEnum(t, "SetupActionOperationComponent", "method", element.getMethodElement(), -1);
22061    }
22062    if (element.hasOriginElement()) {
22063      composeInteger(t, "SetupActionOperationComponent", "origin", element.getOriginElement(), -1);
22064    }
22065    if (element.hasParamsElement()) {
22066      composeString(t, "SetupActionOperationComponent", "params", element.getParamsElement(), -1);
22067    }
22068    for (int i = 0; i < element.getRequestHeader().size(); i++) {
22069      composeTestScriptSetupActionOperationRequestHeaderComponent(t, "SetupActionOperationComponent", "requestHeader", element.getRequestHeader().get(i), i);
22070    }
22071    if (element.hasRequestIdElement()) {
22072      composeId(t, "SetupActionOperationComponent", "requestId", element.getRequestIdElement(), -1);
22073    }
22074    if (element.hasResponseIdElement()) {
22075      composeId(t, "SetupActionOperationComponent", "responseId", element.getResponseIdElement(), -1);
22076    }
22077    if (element.hasSourceIdElement()) {
22078      composeId(t, "SetupActionOperationComponent", "sourceId", element.getSourceIdElement(), -1);
22079    }
22080    if (element.hasTargetIdElement()) {
22081      composeId(t, "SetupActionOperationComponent", "targetId", element.getTargetIdElement(), -1);
22082    }
22083    if (element.hasUrlElement()) {
22084      composeString(t, "SetupActionOperationComponent", "url", element.getUrlElement(), -1);
22085    }
22086  }
22087
22088  protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) {
22089    if (element == null) 
22090      return;
22091    Complex t;
22092    if (Utilities.noString(parentType))
22093      t = parent;
22094    else {
22095      t = parent.predicate("fhir:"+parentType+'.'+name);
22096    }
22097    composeBackboneElement(t, "requestHeader", name, element, index);
22098    if (element.hasFieldElement()) {
22099      composeString(t, "SetupActionOperationRequestHeaderComponent", "field", element.getFieldElement(), -1);
22100    }
22101    if (element.hasValueElement()) {
22102      composeString(t, "SetupActionOperationRequestHeaderComponent", "value", element.getValueElement(), -1);
22103    }
22104  }
22105
22106  protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) {
22107    if (element == null) 
22108      return;
22109    Complex t;
22110    if (Utilities.noString(parentType))
22111      t = parent;
22112    else {
22113      t = parent.predicate("fhir:"+parentType+'.'+name);
22114    }
22115    composeBackboneElement(t, "assert", name, element, index);
22116    if (element.hasLabelElement()) {
22117      composeString(t, "SetupActionAssertComponent", "label", element.getLabelElement(), -1);
22118    }
22119    if (element.hasDescriptionElement()) {
22120      composeString(t, "SetupActionAssertComponent", "description", element.getDescriptionElement(), -1);
22121    }
22122    if (element.hasDirectionElement()) {
22123      composeEnum(t, "SetupActionAssertComponent", "direction", element.getDirectionElement(), -1);
22124    }
22125    if (element.hasCompareToSourceIdElement()) {
22126      composeString(t, "SetupActionAssertComponent", "compareToSourceId", element.getCompareToSourceIdElement(), -1);
22127    }
22128    if (element.hasCompareToSourceExpressionElement()) {
22129      composeString(t, "SetupActionAssertComponent", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1);
22130    }
22131    if (element.hasCompareToSourcePathElement()) {
22132      composeString(t, "SetupActionAssertComponent", "compareToSourcePath", element.getCompareToSourcePathElement(), -1);
22133    }
22134    if (element.hasContentTypeElement()) {
22135      composeCode(t, "SetupActionAssertComponent", "contentType", element.getContentTypeElement(), -1);
22136    }
22137    if (element.hasExpressionElement()) {
22138      composeString(t, "SetupActionAssertComponent", "expression", element.getExpressionElement(), -1);
22139    }
22140    if (element.hasHeaderFieldElement()) {
22141      composeString(t, "SetupActionAssertComponent", "headerField", element.getHeaderFieldElement(), -1);
22142    }
22143    if (element.hasMinimumIdElement()) {
22144      composeString(t, "SetupActionAssertComponent", "minimumId", element.getMinimumIdElement(), -1);
22145    }
22146    if (element.hasNavigationLinksElement()) {
22147      composeBoolean(t, "SetupActionAssertComponent", "navigationLinks", element.getNavigationLinksElement(), -1);
22148    }
22149    if (element.hasOperatorElement()) {
22150      composeEnum(t, "SetupActionAssertComponent", "operator", element.getOperatorElement(), -1);
22151    }
22152    if (element.hasPathElement()) {
22153      composeString(t, "SetupActionAssertComponent", "path", element.getPathElement(), -1);
22154    }
22155    if (element.hasRequestMethodElement()) {
22156      composeEnum(t, "SetupActionAssertComponent", "requestMethod", element.getRequestMethodElement(), -1);
22157    }
22158    if (element.hasRequestURLElement()) {
22159      composeString(t, "SetupActionAssertComponent", "requestURL", element.getRequestURLElement(), -1);
22160    }
22161    if (element.hasResourceElement()) {
22162      composeEnum(t, "SetupActionAssertComponent", "resource", element.getResourceElement(), -1);
22163    }
22164    if (element.hasResponseElement()) {
22165      composeEnum(t, "SetupActionAssertComponent", "response", element.getResponseElement(), -1);
22166    }
22167    if (element.hasResponseCodeElement()) {
22168      composeString(t, "SetupActionAssertComponent", "responseCode", element.getResponseCodeElement(), -1);
22169    }
22170    if (element.hasSourceIdElement()) {
22171      composeId(t, "SetupActionAssertComponent", "sourceId", element.getSourceIdElement(), -1);
22172    }
22173    if (element.hasValidateProfileIdElement()) {
22174      composeId(t, "SetupActionAssertComponent", "validateProfileId", element.getValidateProfileIdElement(), -1);
22175    }
22176    if (element.hasValueElement()) {
22177      composeString(t, "SetupActionAssertComponent", "value", element.getValueElement(), -1);
22178    }
22179    if (element.hasWarningOnlyElement()) {
22180      composeBoolean(t, "SetupActionAssertComponent", "warningOnly", element.getWarningOnlyElement(), -1);
22181    }
22182  }
22183
22184  protected void composeTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) {
22185    if (element == null) 
22186      return;
22187    Complex t;
22188    if (Utilities.noString(parentType))
22189      t = parent;
22190    else {
22191      t = parent.predicate("fhir:"+parentType+'.'+name);
22192    }
22193    composeBackboneElement(t, "test", name, element, index);
22194    if (element.hasNameElement()) {
22195      composeString(t, "TestScriptTestComponent", "name", element.getNameElement(), -1);
22196    }
22197    if (element.hasDescriptionElement()) {
22198      composeString(t, "TestScriptTestComponent", "description", element.getDescriptionElement(), -1);
22199    }
22200    for (int i = 0; i < element.getAction().size(); i++) {
22201      composeTestScriptTestActionComponent(t, "TestScriptTestComponent", "action", element.getAction().get(i), i);
22202    }
22203  }
22204
22205  protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) {
22206    if (element == null) 
22207      return;
22208    Complex t;
22209    if (Utilities.noString(parentType))
22210      t = parent;
22211    else {
22212      t = parent.predicate("fhir:"+parentType+'.'+name);
22213    }
22214    composeBackboneElement(t, "action", name, element, index);
22215    if (element.hasOperation()) {
22216      composeTestScriptSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
22217    }
22218    if (element.hasAssert()) {
22219      composeTestScriptSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
22220    }
22221  }
22222
22223  protected void composeTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) {
22224    if (element == null) 
22225      return;
22226    Complex t;
22227    if (Utilities.noString(parentType))
22228      t = parent;
22229    else {
22230      t = parent.predicate("fhir:"+parentType+'.'+name);
22231    }
22232    composeBackboneElement(t, "teardown", name, element, index);
22233    for (int i = 0; i < element.getAction().size(); i++) {
22234      composeTestScriptTeardownActionComponent(t, "TestScriptTeardownComponent", "action", element.getAction().get(i), i);
22235    }
22236  }
22237
22238  protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) {
22239    if (element == null) 
22240      return;
22241    Complex t;
22242    if (Utilities.noString(parentType))
22243      t = parent;
22244    else {
22245      t = parent.predicate("fhir:"+parentType+'.'+name);
22246    }
22247    composeBackboneElement(t, "action", name, element, index);
22248    if (element.hasOperation()) {
22249      composeTestScriptSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
22250    }
22251  }
22252
22253  protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) {
22254    if (element == null) 
22255      return;
22256    Complex t;
22257    if (Utilities.noString(parentType))
22258      t = parent;
22259    else {
22260      t = parent.predicate("fhir:"+parentType+'.'+name);
22261    }
22262    composeDomainResource(t, "ValueSet", name, element, index);
22263    if (element.hasUrlElement()) {
22264      composeUri(t, "ValueSet", "url", element.getUrlElement(), -1);
22265    }
22266    for (int i = 0; i < element.getIdentifier().size(); i++) {
22267      composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i);
22268    }
22269    if (element.hasVersionElement()) {
22270      composeString(t, "ValueSet", "version", element.getVersionElement(), -1);
22271    }
22272    if (element.hasNameElement()) {
22273      composeString(t, "ValueSet", "name", element.getNameElement(), -1);
22274    }
22275    if (element.hasTitleElement()) {
22276      composeString(t, "ValueSet", "title", element.getTitleElement(), -1);
22277    }
22278    if (element.hasStatusElement()) {
22279      composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1);
22280    }
22281    if (element.hasExperimentalElement()) {
22282      composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1);
22283    }
22284    if (element.hasDateElement()) {
22285      composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1);
22286    }
22287    if (element.hasPublisherElement()) {
22288      composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1);
22289    }
22290    for (int i = 0; i < element.getContact().size(); i++) {
22291      composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i);
22292    }
22293    if (element.hasDescriptionElement()) {
22294      composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1);
22295    }
22296    for (int i = 0; i < element.getUseContext().size(); i++) {
22297      composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i);
22298    }
22299    for (int i = 0; i < element.getJurisdiction().size(); i++) {
22300      composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i);
22301    }
22302    if (element.hasImmutableElement()) {
22303      composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1);
22304    }
22305    if (element.hasPurposeElement()) {
22306      composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1);
22307    }
22308    if (element.hasCopyrightElement()) {
22309      composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1);
22310    }
22311    if (element.hasCompose()) {
22312      composeValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1);
22313    }
22314    if (element.hasExpansion()) {
22315      composeValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1);
22316    }
22317  }
22318
22319  protected void composeValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) {
22320    if (element == null) 
22321      return;
22322    Complex t;
22323    if (Utilities.noString(parentType))
22324      t = parent;
22325    else {
22326      t = parent.predicate("fhir:"+parentType+'.'+name);
22327    }
22328    composeBackboneElement(t, "compose", name, element, index);
22329    if (element.hasLockedDateElement()) {
22330      composeDate(t, "ValueSetComposeComponent", "lockedDate", element.getLockedDateElement(), -1);
22331    }
22332    if (element.hasInactiveElement()) {
22333      composeBoolean(t, "ValueSetComposeComponent", "inactive", element.getInactiveElement(), -1);
22334    }
22335    for (int i = 0; i < element.getInclude().size(); i++) {
22336      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "include", element.getInclude().get(i), i);
22337    }
22338    for (int i = 0; i < element.getExclude().size(); i++) {
22339      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "exclude", element.getExclude().get(i), i);
22340    }
22341  }
22342
22343  protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent element, int index) {
22344    if (element == null) 
22345      return;
22346    Complex t;
22347    if (Utilities.noString(parentType))
22348      t = parent;
22349    else {
22350      t = parent.predicate("fhir:"+parentType+'.'+name);
22351    }
22352    composeBackboneElement(t, "include", name, element, index);
22353    if (element.hasSystemElement()) {
22354      composeUri(t, "ConceptSetComponent", "system", element.getSystemElement(), -1);
22355    }
22356    if (element.hasVersionElement()) {
22357      composeString(t, "ConceptSetComponent", "version", element.getVersionElement(), -1);
22358    }
22359    for (int i = 0; i < element.getConcept().size(); i++) {
22360      composeValueSetConceptReferenceComponent(t, "ConceptSetComponent", "concept", element.getConcept().get(i), i);
22361    }
22362    for (int i = 0; i < element.getFilter().size(); i++) {
22363      composeValueSetConceptSetFilterComponent(t, "ConceptSetComponent", "filter", element.getFilter().get(i), i);
22364    }
22365    for (int i = 0; i < element.getValueSet().size(); i++) {
22366      composeCanonical(t, "ConceptSetComponent", "valueSet", element.getValueSet().get(i), i);
22367    }
22368  }
22369
22370  protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) {
22371    if (element == null) 
22372      return;
22373    Complex t;
22374    if (Utilities.noString(parentType))
22375      t = parent;
22376    else {
22377      t = parent.predicate("fhir:"+parentType+'.'+name);
22378    }
22379    composeBackboneElement(t, "concept", name, element, index);
22380    if (element.hasCodeElement()) {
22381      composeCode(t, "ConceptReferenceComponent", "code", element.getCodeElement(), -1);
22382    }
22383    if (element.hasDisplayElement()) {
22384      composeString(t, "ConceptReferenceComponent", "display", element.getDisplayElement(), -1);
22385    }
22386    for (int i = 0; i < element.getDesignation().size(); i++) {
22387      composeValueSetConceptReferenceDesignationComponent(t, "ConceptReferenceComponent", "designation", element.getDesignation().get(i), i);
22388    }
22389  }
22390
22391  protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) {
22392    if (element == null) 
22393      return;
22394    Complex t;
22395    if (Utilities.noString(parentType))
22396      t = parent;
22397    else {
22398      t = parent.predicate("fhir:"+parentType+'.'+name);
22399    }
22400    composeBackboneElement(t, "designation", name, element, index);
22401    if (element.hasLanguageElement()) {
22402      composeCode(t, "ConceptReferenceDesignationComponent", "language", element.getLanguageElement(), -1);
22403    }
22404    if (element.hasUse()) {
22405      composeCoding(t, "ConceptReferenceDesignationComponent", "use", element.getUse(), -1);
22406    }
22407    if (element.hasValueElement()) {
22408      composeString(t, "ConceptReferenceDesignationComponent", "value", element.getValueElement(), -1);
22409    }
22410  }
22411
22412  protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) {
22413    if (element == null) 
22414      return;
22415    Complex t;
22416    if (Utilities.noString(parentType))
22417      t = parent;
22418    else {
22419      t = parent.predicate("fhir:"+parentType+'.'+name);
22420    }
22421    composeBackboneElement(t, "filter", name, element, index);
22422    if (element.hasPropertyElement()) {
22423      composeCode(t, "ConceptSetFilterComponent", "property", element.getPropertyElement(), -1);
22424    }
22425    if (element.hasOpElement()) {
22426      composeEnum(t, "ConceptSetFilterComponent", "op", element.getOpElement(), -1);
22427    }
22428    if (element.hasValueElement()) {
22429      composeString(t, "ConceptSetFilterComponent", "value", element.getValueElement(), -1);
22430    }
22431  }
22432
22433  protected void composeValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) {
22434    if (element == null) 
22435      return;
22436    Complex t;
22437    if (Utilities.noString(parentType))
22438      t = parent;
22439    else {
22440      t = parent.predicate("fhir:"+parentType+'.'+name);
22441    }
22442    composeBackboneElement(t, "expansion", name, element, index);
22443    if (element.hasIdentifierElement()) {
22444      composeUri(t, "ValueSetExpansionComponent", "identifier", element.getIdentifierElement(), -1);
22445    }
22446    if (element.hasTimestampElement()) {
22447      composeDateTime(t, "ValueSetExpansionComponent", "timestamp", element.getTimestampElement(), -1);
22448    }
22449    if (element.hasTotalElement()) {
22450      composeInteger(t, "ValueSetExpansionComponent", "total", element.getTotalElement(), -1);
22451    }
22452    if (element.hasOffsetElement()) {
22453      composeInteger(t, "ValueSetExpansionComponent", "offset", element.getOffsetElement(), -1);
22454    }
22455    for (int i = 0; i < element.getParameter().size(); i++) {
22456      composeValueSetExpansionParameterComponent(t, "ValueSetExpansionComponent", "parameter", element.getParameter().get(i), i);
22457    }
22458    for (int i = 0; i < element.getContains().size(); i++) {
22459      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionComponent", "contains", element.getContains().get(i), i);
22460    }
22461  }
22462
22463  protected void composeValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) {
22464    if (element == null) 
22465      return;
22466    Complex t;
22467    if (Utilities.noString(parentType))
22468      t = parent;
22469    else {
22470      t = parent.predicate("fhir:"+parentType+'.'+name);
22471    }
22472    composeBackboneElement(t, "parameter", name, element, index);
22473    if (element.hasNameElement()) {
22474      composeString(t, "ValueSetExpansionParameterComponent", "name", element.getNameElement(), -1);
22475    }
22476    if (element.hasValue()) {
22477      composeType(t, "ValueSetExpansionParameterComponent", "value", element.getValue(), -1);
22478    }
22479  }
22480
22481  protected void composeValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) {
22482    if (element == null) 
22483      return;
22484    Complex t;
22485    if (Utilities.noString(parentType))
22486      t = parent;
22487    else {
22488      t = parent.predicate("fhir:"+parentType+'.'+name);
22489    }
22490    composeBackboneElement(t, "contains", name, element, index);
22491    if (element.hasSystemElement()) {
22492      composeUri(t, "ValueSetExpansionContainsComponent", "system", element.getSystemElement(), -1);
22493    }
22494    if (element.hasAbstractElement()) {
22495      composeBoolean(t, "ValueSetExpansionContainsComponent", "abstract", element.getAbstractElement(), -1);
22496    }
22497    if (element.hasInactiveElement()) {
22498      composeBoolean(t, "ValueSetExpansionContainsComponent", "inactive", element.getInactiveElement(), -1);
22499    }
22500    if (element.hasVersionElement()) {
22501      composeString(t, "ValueSetExpansionContainsComponent", "version", element.getVersionElement(), -1);
22502    }
22503    if (element.hasCodeElement()) {
22504      composeCode(t, "ValueSetExpansionContainsComponent", "code", element.getCodeElement(), -1);
22505    }
22506    if (element.hasDisplayElement()) {
22507      composeString(t, "ValueSetExpansionContainsComponent", "display", element.getDisplayElement(), -1);
22508    }
22509    for (int i = 0; i < element.getDesignation().size(); i++) {
22510      composeValueSetConceptReferenceDesignationComponent(t, "ValueSetExpansionContainsComponent", "designation", element.getDesignation().get(i), i);
22511    }
22512    for (int i = 0; i < element.getContains().size(); i++) {
22513      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionContainsComponent", "contains", element.getContains().get(i), i);
22514    }
22515  }
22516
22517  protected void composeVerificationResult(Complex parent, String parentType, String name, VerificationResult element, int index) {
22518    if (element == null) 
22519      return;
22520    Complex t;
22521    if (Utilities.noString(parentType))
22522      t = parent;
22523    else {
22524      t = parent.predicate("fhir:"+parentType+'.'+name);
22525    }
22526    composeDomainResource(t, "VerificationResult", name, element, index);
22527    for (int i = 0; i < element.getTarget().size(); i++) {
22528      composeReference(t, "VerificationResult", "target", element.getTarget().get(i), i);
22529    }
22530    for (int i = 0; i < element.getTargetLocation().size(); i++) {
22531      composeString(t, "VerificationResult", "targetLocation", element.getTargetLocation().get(i), i);
22532    }
22533    if (element.hasNeed()) {
22534      composeCodeableConcept(t, "VerificationResult", "need", element.getNeed(), -1);
22535    }
22536    if (element.hasStatusElement()) {
22537      composeEnum(t, "VerificationResult", "status", element.getStatusElement(), -1);
22538    }
22539    if (element.hasStatusDateElement()) {
22540      composeDateTime(t, "VerificationResult", "statusDate", element.getStatusDateElement(), -1);
22541    }
22542    if (element.hasValidationType()) {
22543      composeCodeableConcept(t, "VerificationResult", "validationType", element.getValidationType(), -1);
22544    }
22545    for (int i = 0; i < element.getValidationProcess().size(); i++) {
22546      composeCodeableConcept(t, "VerificationResult", "validationProcess", element.getValidationProcess().get(i), i);
22547    }
22548    if (element.hasFrequency()) {
22549      composeTiming(t, "VerificationResult", "frequency", element.getFrequency(), -1);
22550    }
22551    if (element.hasLastPerformedElement()) {
22552      composeDateTime(t, "VerificationResult", "lastPerformed", element.getLastPerformedElement(), -1);
22553    }
22554    if (element.hasNextScheduledElement()) {
22555      composeDate(t, "VerificationResult", "nextScheduled", element.getNextScheduledElement(), -1);
22556    }
22557    if (element.hasFailureAction()) {
22558      composeCodeableConcept(t, "VerificationResult", "failureAction", element.getFailureAction(), -1);
22559    }
22560    for (int i = 0; i < element.getPrimarySource().size(); i++) {
22561      composeVerificationResultPrimarySourceComponent(t, "VerificationResult", "primarySource", element.getPrimarySource().get(i), i);
22562    }
22563    if (element.hasAttestation()) {
22564      composeVerificationResultAttestationComponent(t, "VerificationResult", "attestation", element.getAttestation(), -1);
22565    }
22566    for (int i = 0; i < element.getValidator().size(); i++) {
22567      composeVerificationResultValidatorComponent(t, "VerificationResult", "validator", element.getValidator().get(i), i);
22568    }
22569  }
22570
22571  protected void composeVerificationResultPrimarySourceComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultPrimarySourceComponent element, int index) {
22572    if (element == null) 
22573      return;
22574    Complex t;
22575    if (Utilities.noString(parentType))
22576      t = parent;
22577    else {
22578      t = parent.predicate("fhir:"+parentType+'.'+name);
22579    }
22580    composeBackboneElement(t, "primarySource", name, element, index);
22581    if (element.hasWho()) {
22582      composeReference(t, "VerificationResultPrimarySourceComponent", "who", element.getWho(), -1);
22583    }
22584    for (int i = 0; i < element.getType().size(); i++) {
22585      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "type", element.getType().get(i), i);
22586    }
22587    for (int i = 0; i < element.getCommunicationMethod().size(); i++) {
22588      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "communicationMethod", element.getCommunicationMethod().get(i), i);
22589    }
22590    if (element.hasValidationStatus()) {
22591      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "validationStatus", element.getValidationStatus(), -1);
22592    }
22593    if (element.hasValidationDateElement()) {
22594      composeDateTime(t, "VerificationResultPrimarySourceComponent", "validationDate", element.getValidationDateElement(), -1);
22595    }
22596    if (element.hasCanPushUpdates()) {
22597      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "canPushUpdates", element.getCanPushUpdates(), -1);
22598    }
22599    for (int i = 0; i < element.getPushTypeAvailable().size(); i++) {
22600      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "pushTypeAvailable", element.getPushTypeAvailable().get(i), i);
22601    }
22602  }
22603
22604  protected void composeVerificationResultAttestationComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultAttestationComponent element, int index) {
22605    if (element == null) 
22606      return;
22607    Complex t;
22608    if (Utilities.noString(parentType))
22609      t = parent;
22610    else {
22611      t = parent.predicate("fhir:"+parentType+'.'+name);
22612    }
22613    composeBackboneElement(t, "attestation", name, element, index);
22614    if (element.hasWho()) {
22615      composeReference(t, "VerificationResultAttestationComponent", "who", element.getWho(), -1);
22616    }
22617    if (element.hasOnBehalfOf()) {
22618      composeReference(t, "VerificationResultAttestationComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
22619    }
22620    if (element.hasCommunicationMethod()) {
22621      composeCodeableConcept(t, "VerificationResultAttestationComponent", "communicationMethod", element.getCommunicationMethod(), -1);
22622    }
22623    if (element.hasDateElement()) {
22624      composeDate(t, "VerificationResultAttestationComponent", "date", element.getDateElement(), -1);
22625    }
22626    if (element.hasSourceIdentityCertificateElement()) {
22627      composeString(t, "VerificationResultAttestationComponent", "sourceIdentityCertificate", element.getSourceIdentityCertificateElement(), -1);
22628    }
22629    if (element.hasProxyIdentityCertificateElement()) {
22630      composeString(t, "VerificationResultAttestationComponent", "proxyIdentityCertificate", element.getProxyIdentityCertificateElement(), -1);
22631    }
22632    if (element.hasProxySignature()) {
22633      composeSignature(t, "VerificationResultAttestationComponent", "proxySignature", element.getProxySignature(), -1);
22634    }
22635    if (element.hasSourceSignature()) {
22636      composeSignature(t, "VerificationResultAttestationComponent", "sourceSignature", element.getSourceSignature(), -1);
22637    }
22638  }
22639
22640  protected void composeVerificationResultValidatorComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultValidatorComponent element, int index) {
22641    if (element == null) 
22642      return;
22643    Complex t;
22644    if (Utilities.noString(parentType))
22645      t = parent;
22646    else {
22647      t = parent.predicate("fhir:"+parentType+'.'+name);
22648    }
22649    composeBackboneElement(t, "validator", name, element, index);
22650    if (element.hasOrganization()) {
22651      composeReference(t, "VerificationResultValidatorComponent", "organization", element.getOrganization(), -1);
22652    }
22653    if (element.hasIdentityCertificateElement()) {
22654      composeString(t, "VerificationResultValidatorComponent", "identityCertificate", element.getIdentityCertificateElement(), -1);
22655    }
22656    if (element.hasAttestationSignature()) {
22657      composeSignature(t, "VerificationResultValidatorComponent", "attestationSignature", element.getAttestationSignature(), -1);
22658    }
22659  }
22660
22661  protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) {
22662    if (element == null) 
22663      return;
22664    Complex t;
22665    if (Utilities.noString(parentType))
22666      t = parent;
22667    else {
22668      t = parent.predicate("fhir:"+parentType+'.'+name);
22669    }
22670    composeDomainResource(t, "VisionPrescription", name, element, index);
22671    for (int i = 0; i < element.getIdentifier().size(); i++) {
22672      composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i);
22673    }
22674    if (element.hasStatusElement()) {
22675      composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1);
22676    }
22677    if (element.hasCreatedElement()) {
22678      composeDateTime(t, "VisionPrescription", "created", element.getCreatedElement(), -1);
22679    }
22680    if (element.hasPatient()) {
22681      composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1);
22682    }
22683    if (element.hasEncounter()) {
22684      composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1);
22685    }
22686    if (element.hasDateWrittenElement()) {
22687      composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1);
22688    }
22689    if (element.hasPrescriber()) {
22690      composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1);
22691    }
22692    for (int i = 0; i < element.getLensSpecification().size(); i++) {
22693      composeVisionPrescriptionLensSpecificationComponent(t, "VisionPrescription", "lensSpecification", element.getLensSpecification().get(i), i);
22694    }
22695  }
22696
22697  protected void composeVisionPrescriptionLensSpecificationComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionLensSpecificationComponent element, int index) {
22698    if (element == null) 
22699      return;
22700    Complex t;
22701    if (Utilities.noString(parentType))
22702      t = parent;
22703    else {
22704      t = parent.predicate("fhir:"+parentType+'.'+name);
22705    }
22706    composeBackboneElement(t, "lensSpecification", name, element, index);
22707    if (element.hasProduct()) {
22708      composeCodeableConcept(t, "VisionPrescriptionLensSpecificationComponent", "product", element.getProduct(), -1);
22709    }
22710    if (element.hasEyeElement()) {
22711      composeEnum(t, "VisionPrescriptionLensSpecificationComponent", "eye", element.getEyeElement(), -1);
22712    }
22713    if (element.hasSphereElement()) {
22714      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "sphere", element.getSphereElement(), -1);
22715    }
22716    if (element.hasCylinderElement()) {
22717      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "cylinder", element.getCylinderElement(), -1);
22718    }
22719    if (element.hasAxisElement()) {
22720      composeInteger(t, "VisionPrescriptionLensSpecificationComponent", "axis", element.getAxisElement(), -1);
22721    }
22722    for (int i = 0; i < element.getPrism().size(); i++) {
22723      composeVisionPrescriptionPrismComponent(t, "VisionPrescriptionLensSpecificationComponent", "prism", element.getPrism().get(i), i);
22724    }
22725    if (element.hasAddElement()) {
22726      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "add", element.getAddElement(), -1);
22727    }
22728    if (element.hasPowerElement()) {
22729      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "power", element.getPowerElement(), -1);
22730    }
22731    if (element.hasBackCurveElement()) {
22732      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "backCurve", element.getBackCurveElement(), -1);
22733    }
22734    if (element.hasDiameterElement()) {
22735      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "diameter", element.getDiameterElement(), -1);
22736    }
22737    if (element.hasDuration()) {
22738      composeQuantity(t, "VisionPrescriptionLensSpecificationComponent", "duration", element.getDuration(), -1);
22739    }
22740    if (element.hasColorElement()) {
22741      composeString(t, "VisionPrescriptionLensSpecificationComponent", "color", element.getColorElement(), -1);
22742    }
22743    if (element.hasBrandElement()) {
22744      composeString(t, "VisionPrescriptionLensSpecificationComponent", "brand", element.getBrandElement(), -1);
22745    }
22746    for (int i = 0; i < element.getNote().size(); i++) {
22747      composeAnnotation(t, "VisionPrescriptionLensSpecificationComponent", "note", element.getNote().get(i), i);
22748    }
22749  }
22750
22751  protected void composeVisionPrescriptionPrismComponent(Complex parent, String parentType, String name, VisionPrescription.PrismComponent element, int index) {
22752    if (element == null) 
22753      return;
22754    Complex t;
22755    if (Utilities.noString(parentType))
22756      t = parent;
22757    else {
22758      t = parent.predicate("fhir:"+parentType+'.'+name);
22759    }
22760    composeBackboneElement(t, "prism", name, element, index);
22761    if (element.hasAmountElement()) {
22762      composeDecimal(t, "PrismComponent", "amount", element.getAmountElement(), -1);
22763    }
22764    if (element.hasBaseElement()) {
22765      composeEnum(t, "PrismComponent", "base", element.getBaseElement(), -1);
22766    }
22767  }
22768
22769
22770
22771
22772  @Override
22773  protected void composeResource(Complex parent, Resource resource) {
22774    if (parent == null) {
22775      throw new Error("parent == null");
22776    } else if (resource == null) {
22777      throw new Error("resource == null");
22778    } else if (resource instanceof Account) {
22779      composeAccount(parent, null, "Account", (Account)resource, -1);
22780    } else if (resource instanceof ActivityDefinition) {
22781      composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1);
22782    } else if (resource instanceof AdministrableProductDefinition) {
22783      composeAdministrableProductDefinition(parent, null, "AdministrableProductDefinition", (AdministrableProductDefinition)resource, -1);
22784    } else if (resource instanceof AdverseEvent) {
22785      composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1);
22786    } else if (resource instanceof AllergyIntolerance) {
22787      composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1);
22788    } else if (resource instanceof Appointment) {
22789      composeAppointment(parent, null, "Appointment", (Appointment)resource, -1);
22790    } else if (resource instanceof AppointmentResponse) {
22791      composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1);
22792    } else if (resource instanceof AuditEvent) {
22793      composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1);
22794    } else if (resource instanceof Basic) {
22795      composeBasic(parent, null, "Basic", (Basic)resource, -1);
22796    } else if (resource instanceof Binary) {
22797      composeBinary(parent, null, "Binary", (Binary)resource, -1);
22798    } else if (resource instanceof BiologicallyDerivedProduct) {
22799      composeBiologicallyDerivedProduct(parent, null, "BiologicallyDerivedProduct", (BiologicallyDerivedProduct)resource, -1);
22800    } else if (resource instanceof BodyStructure) {
22801      composeBodyStructure(parent, null, "BodyStructure", (BodyStructure)resource, -1);
22802    } else if (resource instanceof Bundle) {
22803      composeBundle(parent, null, "Bundle", (Bundle)resource, -1);
22804    } else if (resource instanceof CapabilityStatement) {
22805      composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1);
22806    } else if (resource instanceof CarePlan) {
22807      composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1);
22808    } else if (resource instanceof CareTeam) {
22809      composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1);
22810    } else if (resource instanceof CatalogEntry) {
22811      composeCatalogEntry(parent, null, "CatalogEntry", (CatalogEntry)resource, -1);
22812    } else if (resource instanceof ChargeItem) {
22813      composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1);
22814    } else if (resource instanceof ChargeItemDefinition) {
22815      composeChargeItemDefinition(parent, null, "ChargeItemDefinition", (ChargeItemDefinition)resource, -1);
22816    } else if (resource instanceof Citation) {
22817      composeCitation(parent, null, "Citation", (Citation)resource, -1);
22818    } else if (resource instanceof Claim) {
22819      composeClaim(parent, null, "Claim", (Claim)resource, -1);
22820    } else if (resource instanceof ClaimResponse) {
22821      composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1);
22822    } else if (resource instanceof ClinicalImpression) {
22823      composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1);
22824    } else if (resource instanceof ClinicalUseDefinition) {
22825      composeClinicalUseDefinition(parent, null, "ClinicalUseDefinition", (ClinicalUseDefinition)resource, -1);
22826    } else if (resource instanceof CodeSystem) {
22827      composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1);
22828    } else if (resource instanceof Communication) {
22829      composeCommunication(parent, null, "Communication", (Communication)resource, -1);
22830    } else if (resource instanceof CommunicationRequest) {
22831      composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1);
22832    } else if (resource instanceof CompartmentDefinition) {
22833      composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1);
22834    } else if (resource instanceof Composition) {
22835      composeComposition(parent, null, "Composition", (Composition)resource, -1);
22836    } else if (resource instanceof ConceptMap) {
22837      composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1);
22838    } else if (resource instanceof Condition) {
22839      composeCondition(parent, null, "Condition", (Condition)resource, -1);
22840    } else if (resource instanceof Consent) {
22841      composeConsent(parent, null, "Consent", (Consent)resource, -1);
22842    } else if (resource instanceof Contract) {
22843      composeContract(parent, null, "Contract", (Contract)resource, -1);
22844    } else if (resource instanceof Coverage) {
22845      composeCoverage(parent, null, "Coverage", (Coverage)resource, -1);
22846    } else if (resource instanceof CoverageEligibilityRequest) {
22847      composeCoverageEligibilityRequest(parent, null, "CoverageEligibilityRequest", (CoverageEligibilityRequest)resource, -1);
22848    } else if (resource instanceof CoverageEligibilityResponse) {
22849      composeCoverageEligibilityResponse(parent, null, "CoverageEligibilityResponse", (CoverageEligibilityResponse)resource, -1);
22850    } else if (resource instanceof DetectedIssue) {
22851      composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1);
22852    } else if (resource instanceof Device) {
22853      composeDevice(parent, null, "Device", (Device)resource, -1);
22854    } else if (resource instanceof DeviceDefinition) {
22855      composeDeviceDefinition(parent, null, "DeviceDefinition", (DeviceDefinition)resource, -1);
22856    } else if (resource instanceof DeviceMetric) {
22857      composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1);
22858    } else if (resource instanceof DeviceRequest) {
22859      composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1);
22860    } else if (resource instanceof DeviceUseStatement) {
22861      composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1);
22862    } else if (resource instanceof DiagnosticReport) {
22863      composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1);
22864    } else if (resource instanceof DocumentManifest) {
22865      composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1);
22866    } else if (resource instanceof DocumentReference) {
22867      composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1);
22868    } else if (resource instanceof Encounter) {
22869      composeEncounter(parent, null, "Encounter", (Encounter)resource, -1);
22870    } else if (resource instanceof Endpoint) {
22871      composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1);
22872    } else if (resource instanceof EnrollmentRequest) {
22873      composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1);
22874    } else if (resource instanceof EnrollmentResponse) {
22875      composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1);
22876    } else if (resource instanceof EpisodeOfCare) {
22877      composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1);
22878    } else if (resource instanceof EventDefinition) {
22879      composeEventDefinition(parent, null, "EventDefinition", (EventDefinition)resource, -1);
22880    } else if (resource instanceof Evidence) {
22881      composeEvidence(parent, null, "Evidence", (Evidence)resource, -1);
22882    } else if (resource instanceof EvidenceReport) {
22883      composeEvidenceReport(parent, null, "EvidenceReport", (EvidenceReport)resource, -1);
22884    } else if (resource instanceof EvidenceVariable) {
22885      composeEvidenceVariable(parent, null, "EvidenceVariable", (EvidenceVariable)resource, -1);
22886    } else if (resource instanceof ExampleScenario) {
22887      composeExampleScenario(parent, null, "ExampleScenario", (ExampleScenario)resource, -1);
22888    } else if (resource instanceof ExplanationOfBenefit) {
22889      composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1);
22890    } else if (resource instanceof FamilyMemberHistory) {
22891      composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1);
22892    } else if (resource instanceof Flag) {
22893      composeFlag(parent, null, "Flag", (Flag)resource, -1);
22894    } else if (resource instanceof Goal) {
22895      composeGoal(parent, null, "Goal", (Goal)resource, -1);
22896    } else if (resource instanceof GraphDefinition) {
22897      composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1);
22898    } else if (resource instanceof Group) {
22899      composeGroup(parent, null, "Group", (Group)resource, -1);
22900    } else if (resource instanceof GuidanceResponse) {
22901      composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1);
22902    } else if (resource instanceof HealthcareService) {
22903      composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1);
22904    } else if (resource instanceof ImagingStudy) {
22905      composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1);
22906    } else if (resource instanceof Immunization) {
22907      composeImmunization(parent, null, "Immunization", (Immunization)resource, -1);
22908    } else if (resource instanceof ImmunizationEvaluation) {
22909      composeImmunizationEvaluation(parent, null, "ImmunizationEvaluation", (ImmunizationEvaluation)resource, -1);
22910    } else if (resource instanceof ImmunizationRecommendation) {
22911      composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1);
22912    } else if (resource instanceof ImplementationGuide) {
22913      composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1);
22914    } else if (resource instanceof Ingredient) {
22915      composeIngredient(parent, null, "Ingredient", (Ingredient)resource, -1);
22916    } else if (resource instanceof InsurancePlan) {
22917      composeInsurancePlan(parent, null, "InsurancePlan", (InsurancePlan)resource, -1);
22918    } else if (resource instanceof Invoice) {
22919      composeInvoice(parent, null, "Invoice", (Invoice)resource, -1);
22920    } else if (resource instanceof Library) {
22921      composeLibrary(parent, null, "Library", (Library)resource, -1);
22922    } else if (resource instanceof Linkage) {
22923      composeLinkage(parent, null, "Linkage", (Linkage)resource, -1);
22924    } else if (resource instanceof ListResource) {
22925      composeListResource(parent, null, "List", (ListResource)resource, -1);
22926    } else if (resource instanceof Location) {
22927      composeLocation(parent, null, "Location", (Location)resource, -1);
22928    } else if (resource instanceof ManufacturedItemDefinition) {
22929      composeManufacturedItemDefinition(parent, null, "ManufacturedItemDefinition", (ManufacturedItemDefinition)resource, -1);
22930    } else if (resource instanceof Measure) {
22931      composeMeasure(parent, null, "Measure", (Measure)resource, -1);
22932    } else if (resource instanceof MeasureReport) {
22933      composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1);
22934    } else if (resource instanceof Media) {
22935      composeMedia(parent, null, "Media", (Media)resource, -1);
22936    } else if (resource instanceof Medication) {
22937      composeMedication(parent, null, "Medication", (Medication)resource, -1);
22938    } else if (resource instanceof MedicationAdministration) {
22939      composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1);
22940    } else if (resource instanceof MedicationDispense) {
22941      composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1);
22942    } else if (resource instanceof MedicationKnowledge) {
22943      composeMedicationKnowledge(parent, null, "MedicationKnowledge", (MedicationKnowledge)resource, -1);
22944    } else if (resource instanceof MedicationRequest) {
22945      composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1);
22946    } else if (resource instanceof MedicationStatement) {
22947      composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1);
22948    } else if (resource instanceof MedicinalProductDefinition) {
22949      composeMedicinalProductDefinition(parent, null, "MedicinalProductDefinition", (MedicinalProductDefinition)resource, -1);
22950    } else if (resource instanceof MessageDefinition) {
22951      composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1);
22952    } else if (resource instanceof MessageHeader) {
22953      composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1);
22954    } else if (resource instanceof MolecularSequence) {
22955      composeMolecularSequence(parent, null, "MolecularSequence", (MolecularSequence)resource, -1);
22956    } else if (resource instanceof NamingSystem) {
22957      composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1);
22958    } else if (resource instanceof NutritionOrder) {
22959      composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1);
22960    } else if (resource instanceof NutritionProduct) {
22961      composeNutritionProduct(parent, null, "NutritionProduct", (NutritionProduct)resource, -1);
22962    } else if (resource instanceof Observation) {
22963      composeObservation(parent, null, "Observation", (Observation)resource, -1);
22964    } else if (resource instanceof ObservationDefinition) {
22965      composeObservationDefinition(parent, null, "ObservationDefinition", (ObservationDefinition)resource, -1);
22966    } else if (resource instanceof OperationDefinition) {
22967      composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1);
22968    } else if (resource instanceof OperationOutcome) {
22969      composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1);
22970    } else if (resource instanceof Organization) {
22971      composeOrganization(parent, null, "Organization", (Organization)resource, -1);
22972    } else if (resource instanceof OrganizationAffiliation) {
22973      composeOrganizationAffiliation(parent, null, "OrganizationAffiliation", (OrganizationAffiliation)resource, -1);
22974    } else if (resource instanceof PackagedProductDefinition) {
22975      composePackagedProductDefinition(parent, null, "PackagedProductDefinition", (PackagedProductDefinition)resource, -1);
22976    } else if (resource instanceof Parameters) {
22977      composeParameters(parent, null, "Parameters", (Parameters)resource, -1);
22978    } else if (resource instanceof Patient) {
22979      composePatient(parent, null, "Patient", (Patient)resource, -1);
22980    } else if (resource instanceof PaymentNotice) {
22981      composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1);
22982    } else if (resource instanceof PaymentReconciliation) {
22983      composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1);
22984    } else if (resource instanceof Person) {
22985      composePerson(parent, null, "Person", (Person)resource, -1);
22986    } else if (resource instanceof PlanDefinition) {
22987      composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1);
22988    } else if (resource instanceof Practitioner) {
22989      composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1);
22990    } else if (resource instanceof PractitionerRole) {
22991      composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1);
22992    } else if (resource instanceof Procedure) {
22993      composeProcedure(parent, null, "Procedure", (Procedure)resource, -1);
22994    } else if (resource instanceof Provenance) {
22995      composeProvenance(parent, null, "Provenance", (Provenance)resource, -1);
22996    } else if (resource instanceof Questionnaire) {
22997      composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1);
22998    } else if (resource instanceof QuestionnaireResponse) {
22999      composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1);
23000    } else if (resource instanceof RegulatedAuthorization) {
23001      composeRegulatedAuthorization(parent, null, "RegulatedAuthorization", (RegulatedAuthorization)resource, -1);
23002    } else if (resource instanceof RelatedPerson) {
23003      composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1);
23004    } else if (resource instanceof RequestGroup) {
23005      composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1);
23006    } else if (resource instanceof ResearchDefinition) {
23007      composeResearchDefinition(parent, null, "ResearchDefinition", (ResearchDefinition)resource, -1);
23008    } else if (resource instanceof ResearchElementDefinition) {
23009      composeResearchElementDefinition(parent, null, "ResearchElementDefinition", (ResearchElementDefinition)resource, -1);
23010    } else if (resource instanceof ResearchStudy) {
23011      composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1);
23012    } else if (resource instanceof ResearchSubject) {
23013      composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1);
23014    } else if (resource instanceof RiskAssessment) {
23015      composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1);
23016    } else if (resource instanceof Schedule) {
23017      composeSchedule(parent, null, "Schedule", (Schedule)resource, -1);
23018    } else if (resource instanceof SearchParameter) {
23019      composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1);
23020    } else if (resource instanceof ServiceRequest) {
23021      composeServiceRequest(parent, null, "ServiceRequest", (ServiceRequest)resource, -1);
23022    } else if (resource instanceof Slot) {
23023      composeSlot(parent, null, "Slot", (Slot)resource, -1);
23024    } else if (resource instanceof Specimen) {
23025      composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1);
23026    } else if (resource instanceof SpecimenDefinition) {
23027      composeSpecimenDefinition(parent, null, "SpecimenDefinition", (SpecimenDefinition)resource, -1);
23028    } else if (resource instanceof StructureDefinition) {
23029      composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1);
23030    } else if (resource instanceof StructureMap) {
23031      composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1);
23032    } else if (resource instanceof Subscription) {
23033      composeSubscription(parent, null, "Subscription", (Subscription)resource, -1);
23034    } else if (resource instanceof SubscriptionStatus) {
23035      composeSubscriptionStatus(parent, null, "SubscriptionStatus", (SubscriptionStatus)resource, -1);
23036    } else if (resource instanceof SubscriptionTopic) {
23037      composeSubscriptionTopic(parent, null, "SubscriptionTopic", (SubscriptionTopic)resource, -1);
23038    } else if (resource instanceof Substance) {
23039      composeSubstance(parent, null, "Substance", (Substance)resource, -1);
23040    } else if (resource instanceof SubstanceDefinition) {
23041      composeSubstanceDefinition(parent, null, "SubstanceDefinition", (SubstanceDefinition)resource, -1);
23042    } else if (resource instanceof SupplyDelivery) {
23043      composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1);
23044    } else if (resource instanceof SupplyRequest) {
23045      composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1);
23046    } else if (resource instanceof Task) {
23047      composeTask(parent, null, "Task", (Task)resource, -1);
23048    } else if (resource instanceof TerminologyCapabilities) {
23049      composeTerminologyCapabilities(parent, null, "TerminologyCapabilities", (TerminologyCapabilities)resource, -1);
23050    } else if (resource instanceof TestReport) {
23051      composeTestReport(parent, null, "TestReport", (TestReport)resource, -1);
23052    } else if (resource instanceof TestScript) {
23053      composeTestScript(parent, null, "TestScript", (TestScript)resource, -1);
23054    } else if (resource instanceof ValueSet) {
23055      composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1);
23056    } else if (resource instanceof VerificationResult) {
23057      composeVerificationResult(parent, null, "VerificationResult", (VerificationResult)resource, -1);
23058    } else if (resource instanceof VisionPrescription) {
23059      composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1);
23060      
23061    } else {
23062      throw new Error("Unhandled resource type "+resource.getClass().getName());
23063    }
23064  }
23065
23066  protected void composeType(Complex parent, String parentType, String name, DataType value, int index) {
23067    if (parent == null) {
23068      throw new Error("parent == null");
23069    } else if (parentType == null) {
23070      throw new Error("parentType == null");
23071    } else if (name == null) {
23072      throw new Error("name == null");
23073    } else if (value == null) {
23074      throw new Error("value == null");
23075    } else if (value instanceof DateType) {
23076      composeDate(parent, parentType, name, (DateType)value, index);
23077    } else if (value instanceof DateTimeType) {
23078      composeDateTime(parent, parentType, name, (DateTimeType)value, index);
23079    } else if (value instanceof CodeType) {
23080      composeCode(parent, parentType, name, (CodeType)value, index);
23081    } else if (value instanceof StringType) {
23082      composeString(parent, parentType, name, (StringType)value, index);
23083    } else if (value instanceof IntegerType) {
23084      composeInteger(parent, parentType, name, (IntegerType)value, index);
23085    } else if (value instanceof Integer64Type) {
23086      composeInteger64(parent, parentType, name, (Integer64Type)value, index);
23087    } else if (value instanceof OidType) {
23088      composeOid(parent, parentType, name, (OidType)value, index);
23089    } else if (value instanceof CanonicalType) {
23090      composeCanonical(parent, parentType, name, (CanonicalType)value, index);
23091    } else if (value instanceof UriType) {
23092      composeUri(parent, parentType, name, (UriType)value, index);
23093    } else if (value instanceof UuidType) {
23094      composeUuid(parent, parentType, name, (UuidType)value, index);
23095    } else if (value instanceof UrlType) {
23096      composeUrl(parent, parentType, name, (UrlType)value, index);
23097    } else if (value instanceof InstantType) {
23098      composeInstant(parent, parentType, name, (InstantType)value, index);
23099    } else if (value instanceof BooleanType) {
23100      composeBoolean(parent, parentType, name, (BooleanType)value, index);
23101    } else if (value instanceof Base64BinaryType) {
23102      composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index);
23103    } else if (value instanceof UnsignedIntType) {
23104      composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index);
23105    } else if (value instanceof MarkdownType) {
23106      composeMarkdown(parent, parentType, name, (MarkdownType)value, index);
23107    } else if (value instanceof TimeType) {
23108      composeTime(parent, parentType, name, (TimeType)value, index);
23109    } else if (value instanceof IdType) {
23110      composeId(parent, parentType, name, (IdType)value, index);
23111    } else if (value instanceof PositiveIntType) {
23112      composePositiveInt(parent, parentType, name, (PositiveIntType)value, index);
23113    } else if (value instanceof DecimalType) {
23114      composeDecimal(parent, parentType, name, (DecimalType)value, index);
23115    } else if (value instanceof Address) {
23116      composeAddress(parent, parentType, name, (Address)value, index);
23117    } else if (value instanceof Age) {
23118      composeAge(parent, parentType, name, (Age)value, index);
23119    } else if (value instanceof Annotation) {
23120      composeAnnotation(parent, parentType, name, (Annotation)value, index);
23121    } else if (value instanceof Attachment) {
23122      composeAttachment(parent, parentType, name, (Attachment)value, index);
23123    } else if (value instanceof CodeableConcept) {
23124      composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index);
23125    } else if (value instanceof CodeableReference) {
23126      composeCodeableReference(parent, parentType, name, (CodeableReference)value, index);
23127    } else if (value instanceof Coding) {
23128      composeCoding(parent, parentType, name, (Coding)value, index);
23129    } else if (value instanceof ContactDetail) {
23130      composeContactDetail(parent, parentType, name, (ContactDetail)value, index);
23131    } else if (value instanceof ContactPoint) {
23132      composeContactPoint(parent, parentType, name, (ContactPoint)value, index);
23133    } else if (value instanceof Contributor) {
23134      composeContributor(parent, parentType, name, (Contributor)value, index);
23135    } else if (value instanceof Count) {
23136      composeCount(parent, parentType, name, (Count)value, index);
23137    } else if (value instanceof DataRequirement) {
23138      composeDataRequirement(parent, parentType, name, (DataRequirement)value, index);
23139    } else if (value instanceof Distance) {
23140      composeDistance(parent, parentType, name, (Distance)value, index);
23141    } else if (value instanceof Dosage) {
23142      composeDosage(parent, parentType, name, (Dosage)value, index);
23143    } else if (value instanceof Duration) {
23144      composeDuration(parent, parentType, name, (Duration)value, index);
23145    } else if (value instanceof ElementDefinition) {
23146      composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index);
23147    } else if (value instanceof Expression) {
23148      composeExpression(parent, parentType, name, (Expression)value, index);
23149    } else if (value instanceof Extension) {
23150      composeExtension(parent, parentType, name, (Extension)value, index);
23151    } else if (value instanceof HumanName) {
23152      composeHumanName(parent, parentType, name, (HumanName)value, index);
23153    } else if (value instanceof Identifier) {
23154      composeIdentifier(parent, parentType, name, (Identifier)value, index);
23155    } else if (value instanceof MarketingStatus) {
23156      composeMarketingStatus(parent, parentType, name, (MarketingStatus)value, index);
23157    } else if (value instanceof Meta) {
23158      composeMeta(parent, parentType, name, (Meta)value, index);
23159    } else if (value instanceof Money) {
23160      composeMoney(parent, parentType, name, (Money)value, index);
23161    } else if (value instanceof Narrative) {
23162      composeNarrative(parent, parentType, name, (Narrative)value, index);
23163    } else if (value instanceof ParameterDefinition) {
23164      composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index);
23165    } else if (value instanceof Period) {
23166      composePeriod(parent, parentType, name, (Period)value, index);
23167    } else if (value instanceof Population) {
23168      composePopulation(parent, parentType, name, (Population)value, index);
23169    } else if (value instanceof ProdCharacteristic) {
23170      composeProdCharacteristic(parent, parentType, name, (ProdCharacteristic)value, index);
23171    } else if (value instanceof ProductShelfLife) {
23172      composeProductShelfLife(parent, parentType, name, (ProductShelfLife)value, index);
23173    } else if (value instanceof Quantity) {
23174      composeQuantity(parent, parentType, name, (Quantity)value, index);
23175    } else if (value instanceof Range) {
23176      composeRange(parent, parentType, name, (Range)value, index);
23177    } else if (value instanceof Ratio) {
23178      composeRatio(parent, parentType, name, (Ratio)value, index);
23179    } else if (value instanceof RatioRange) {
23180      composeRatioRange(parent, parentType, name, (RatioRange)value, index);
23181    } else if (value instanceof Reference) {
23182      composeReference(parent, parentType, name, (Reference)value, index);
23183    } else if (value instanceof RelatedArtifact) {
23184      composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index);
23185    } else if (value instanceof SampledData) {
23186      composeSampledData(parent, parentType, name, (SampledData)value, index);
23187    } else if (value instanceof Signature) {
23188      composeSignature(parent, parentType, name, (Signature)value, index);
23189    } else if (value instanceof Timing) {
23190      composeTiming(parent, parentType, name, (Timing)value, index);
23191    } else if (value instanceof TriggerDefinition) {
23192      composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index);
23193    } else if (value instanceof UsageContext) {
23194      composeUsageContext(parent, parentType, name, (UsageContext)value, index);
23195      
23196    } else {
23197      throw new Error("Unhandled type");
23198    }
23199  }
23200
23201}